# github-multi.tcl
# Supports ANY public owner/repo via !gh commands
# Polls and auto-announces only the defined repos
namespace eval ::github {
variable cfg
variable state
variable repos
variable cmd_cooldown
variable default_repo "boxlabss/PASTE"
array set cfg {
poll_interval 120
token "GITHUBTOKENHERE"
per_page 5
timeout_ms 10000
state_file "github_state.txt"
announce_on_start 0
cmd_limit 3
}
array set repos {
"boxlabss/PASTE" {master "#PASTE"}
"boxlabss/HexDroid" {main "#HexDroid"}
}
# map for monitored repos
array set repo_map {}
foreach r [array names repos] {
set repo_map([string tolower $r]) $r
}
array set state {}
array set cmd_cooldown {}
}
# DEPENDENCIES
package require http
package require tls
package require json
::tls::init -ssl2 0 -ssl3 0 -tls1 1 -tls1.1 1 -tls1.2 1 -tls1.3 1
::http::register https 443 ::tls::socket
::http::config -useragent "eggdrop-github-multi/1.6"
# SAVE / LOAD STATE
proc ::github::save_state {} {
variable cfg
variable state
set f [open $cfg(state_file) w]
puts $f [array get state]
close $f
}
proc ::github::load_state {} {
variable cfg
variable state
if {![file exists $cfg(state_file)]} return
set f [open $cfg(state_file) r]
catch {array set state [read $f]}
close $f
}
# HTTP GET WRAPPER
proc ::github::http_get {url {extraHeaders {}}} {
variable cfg
set headers [list Accept "application/vnd.github+json" User-Agent "eggdrop-github-multi/1.6"]
if {[string length $cfg(token)]} { lappend headers Authorization "Bearer $cfg(token)" }
if {[llength $extraHeaders]} { set headers [concat $headers $extraHeaders] }
set tok [::http::geturl $url -headers $headers -timeout $cfg(timeout_ms)]
set code [lindex [split [::http::code $tok]] 1]
set body [::http::data $tok]
set meta [::http::meta $tok]
array set H {}
foreach {k v} $meta { set H([string tolower $k]) $v }
::http::cleanup $tok
return [list $code $body [array get H]]
}
proc ::github::say {channel msg} {
if {$channel eq ""} return
putserv "PRIVMSG $channel :$msg"
}
proc ::github::shortmsg {text maxlen} {
set line [string trim [lindex [split $text \n] 0]]
if {[string length $line] > $maxlen} {
set line "[string range $line 0 [expr {$maxlen-4}]]..."
}
return $line
}
# DATA FETCHERS
proc ::github::fetch_latest_commit {repo branch} {
set url "https://api.github.com/repos/$repo/commits?per_page=1&sha=$branch"
lassign [::github::http_get $url] code body H
if {$code < 200 || $code >= 300} { return {} }
set data [::json::json2dict $body]
if {![llength $data]} { return {} }
set item [lindex $data 0]
set sha [dict get $item sha]
set commit [dict get $item commit]
set msg [dict get $commit message]
set url [dict get $item html_url]
if {[dict exists $item author] && [dict get $item author] ne ""} {
set author [dict get [dict get $item author] login]
} else {
set author [dict get [dict get $commit author] name]
}
return [list sha $sha author $author message $msg url $url]
}
proc ::github::fetch_commits {repo branch} {
variable cfg
variable state
set url "https://api.github.com/repos/$repo/commits?per_page=$cfg(per_page)&sha=$branch"
set headers {}
if {[info exists state($repo,etag_commits)]} {
lappend headers If-None-Match $state($repo,etag_commits)
}
lassign [::github::http_get $url $headers] code body H
if {$code == 304} { return {} }
if {$code < 200 || $code >= 300} { return {} }
if {[dict exists $H etag]} { set state($repo,etag_commits) [dict get $H etag] }
set data [::json::json2dict $body]
set out {}
foreach item $data {
set sha [dict get $item sha]
if {[info exists state($repo,last_commit_sha)] && $sha eq $state($repo,last_commit_sha)} break
set commit [dict get $item commit]
set msg [dict get $commit message]
set url [dict get $item html_url]
if {[dict exists $item author] && [dict get $item author] ne ""} {
set author [dict get [dict get $item author] login]
} else {
set author [dict get [dict get $commit author] name]
}
lappend out [list sha $sha author $author message $msg url $url]
}
return $out
}
proc ::github::fetch_issues {repo {limit 0}} {
variable cfg
if {$limit == 0} { set limit $cfg(per_page) }
set url "https://api.github.com/repos/$repo/issues?state=open&sort=created&direction=desc&per_page=$limit"
lassign [::github::http_get $url] code body H
if {$code < 200 || $code >= 300} { return {} }
set data [::json::json2dict $body]
set out {}
foreach item $data {
if {[dict exists $item pull_request]} continue
lappend out [list id [dict get $item id] number [dict get $item number] \
title [dict get $item title] user [dict get [dict get $item user] login] \
url [dict get $item html_url]]
}
return $out
}
# ANNOUNCEMENTS
proc ::github::announce_commits {repo branch channel commits} {
variable state
foreach c [lreverse $commits] {
array set C $c
set msg [::github::shortmsg $C(message) 140]
::github::say $channel "🧩 $repo@$branch: $C(author) committed “$msg” — $C(url)"
set state($repo,last_commit_sha) $C(sha)
}
}
proc ::github::announce_issues {repo channel issues} {
variable state
if {![info exists state($repo,seen_issue_ids)]} { set state($repo,seen_issue_ids) {} }
foreach i [lreverse $issues] {
array set I $i
if {[lsearch -exact $state($repo,seen_issue_ids) $I(id)] >= 0} continue
::github::say $channel "🐞 New issue #$I(number) by $I(user): $I(title) — $I(url)"
lappend state($repo,seen_issue_ids) $I(id)
if {[llength $state($repo,seen_issue_ids)] > 200} {
set state($repo,seen_issue_ids) [lrange $state($repo,seen_issue_ids) end-199 end]
}
}
}
# POLLING
proc ::github::poll {} {
variable repos
variable cfg
foreach repo [array names repos] {
lassign $repos($repo) branch channel
set commits [::github::fetch_commits $repo $branch]
if {[llength $commits]} { ::github::announce_commits $repo $branch $channel $commits }
set issues [::github::fetch_issues $repo]
if {[llength $issues]} { ::github::announce_issues $repo $channel $issues }
}
::github::save_state
utimer $cfg(poll_interval) ::github::poll
}
# COMMAND HELPERS
proc ::github::cooldown_ok {chan} {
variable cmd_cooldown
set now [unixtime]
if {[info exists cmd_cooldown($chan)] && ($now - $cmd_cooldown($chan)) < 8} { return 0 }
set cmd_cooldown($chan) $now
return 1
}
proc ::github::get_canonical_repo {input} {
variable repo_map
set lower [string tolower $input]
return [expr {[info exists repo_map($lower)] ? $repo_map($lower) : $input}]
}
proc ::github::get_default_branch {repo} {
set url "https://api.github.com/repos/$repo"
lassign [::github::http_get $url] code body H
if {$code != 200} {
putlog "github: failed to get default branch for $repo (HTTP $code)"
return "main"
}
set data [::json::json2dict $body]
if {[dict exists $data default_branch]} {
return [dict get $data default_branch]
}
return "main"
}
proc ::github::get_branch {repo} {
variable repos
if {[info exists repos($repo)]} {
return [lindex $repos($repo) 0]
}
return [::github::get_default_branch $repo]
}
# USER COMMANDS
proc ::github::cmd_latest {chan repo} {
set branch [::github::get_branch $repo]
set latest [::github::fetch_latest_commit $repo $branch]
if {[llength $latest]} {
array set C $latest
set msg [::github::shortmsg $C(message) 100]
putserv "PRIVMSG $chan :🧩 Latest commit: $repo@$branch → $C(author): $msg — $C(url)"
} else {
putserv "PRIVMSG $chan :❌ Could not fetch latest commit for $repo (repo may not exist, be private, or rate-limited)"
}
set issues [::github::fetch_issues $repo 1]
if {[llength $issues]} {
array set I [lindex $issues 0]
putserv "PRIVMSG $chan :🐞 Latest open issue: #$I(number) by $I(user): $I(title) — $I(url)"
}
}
proc ::github::cmd_commits {chan repo} {
variable cfg
set branch [::github::get_branch $repo]
putserv "PRIVMSG $chan :🧩 Last $cfg(cmd_limit) commits for $repo@$branch:"
set url "https://api.github.com/repos/$repo/commits?per_page=$cfg(cmd_limit)&sha=$branch"
lassign [::github::http_get $url] code body H
if {$code < 200 || $code >= 300} {
putserv "PRIVMSG $chan :❌ Error fetching commits (HTTP $code) — repo may not exist or be private"
return
}
set data [::json::json2dict $body]
if {![llength $data]} {
putserv "PRIVMSG $chan :No commits found on branch $branch"
return
}
foreach item $data {
set commit [dict get $item commit]
set msg [::github::shortmsg [dict get $commit message] 80]
set url [dict get $item html_url]
putserv "PRIVMSG $chan :• $msg — $url"
}
}
proc ::github::cmd_issues {chan repo} {
variable cfg
putserv "PRIVMSG $chan :🐞 Last $cfg(cmd_limit) open issues for $repo:"
set issues [::github::fetch_issues $repo $cfg(cmd_limit)]
if {![llength $issues]} {
putserv "PRIVMSG $chan :No open issues found (repo may not exist, be private, or have none open)."
return
}
foreach i $issues {
array set I $i
putserv "PRIVMSG $chan :• #$I(number): $I(title) — $I(url)"
}
}
proc ::github::cmd_dispatch {nick host hand chan text} {
variable default_repo
if {![::github::cooldown_ok $chan]} return
set args [split [string trim $text]]
set sub [string tolower [lindex $args 0]]
set input [lindex $args 1]
if {$input eq ""} {
set repo $default_repo
} else {
set repo [::github::get_canonical_repo $input]
}
switch -- $sub {
latest { ::github::cmd_latest $chan $repo }
commits { ::github::cmd_commits $chan $repo }
issues { ::github::cmd_issues $chan $repo }
default {
putserv "PRIVMSG $chan :Usage: !gh <latest|commits|issues> \[owner/repo\]"
putserv "PRIVMSG $chan :Monitored (auto-announce): [join [array names ::github::repos] ", "]"
putserv "PRIVMSG $chan :Any public repo works for on-demand queries (e.g. !gh commits evilnet/x3)"
}
}
}
bind pub - "!gh" ::github::cmd_dispatch
proc ::github::init {event} {
::github::load_state
if {!$::github::cfg(announce_on_start)} {
foreach repo [array names ::github::repos] {
lassign $::github::repos($repo) branch channel
set first [::github::fetch_latest_commit $repo $branch]
if {[llength $first]} {
array set C $first
set ::github::state($repo,last_commit_sha) $C(sha)
}
set issues [::github::fetch_issues $repo 5]
foreach i $issues {
array set I $i
lappend ::github::state($repo,seen_issue_ids) $I(id)
}
}
::github::save_state
}
putlog "github-multi: monitoring started"
utimer 5 ::github::poll
}
bind evnt - init-server ::github::init