antcolony

11.0 KB

1. // claude.hl — running ONE headless Claude Code session (shared by the worker in work.hl and the
2. // controller in controller.hl, mission 019) and reading its `--output-format json` answer.
3. import { spawnArgs, env } from 'hl:proc'
4. import { exists } from 'hl:fs'
5. import { after, now } from 'hl:time'
6. import { randomBytes } from 'hl:crypto'
7. import { readJson, option, isList, isObject } from './util.hl'
9. // every mode Claude Code has EXCEPT bypassPermissions (the mission rule: never bypass)
10. static MODES = ['auto' 'acceptEdits' 'default' 'dontAsk' 'plan' 'manual']
12. // `--flag value`, else env NAME, else the fallback
13. static setting = (argv, flag, name, fallback) => {
14. let v = option(argv, flag)
15. if (v == null || v == '') { v = env(name) }
16. if (v == null || v == '') { return fallback }
17. return v
18. }
20. static isWholeNumber = (s) => {
21. if (s == null || s == '') { return false }
22. let i = 0
23. while (i < s.length) {
24. let c = s.charCodeAt(i)
25. if (c < 48 || c > 57) { return false }
26. i = i + 1
27. }
28. return true
29. }
31. // a random UUID v4 for `claude --session-id`
32. static uuid = () => {
33. let h = randomBytes(16, 'hex')
34. return h.slice(0, 8) + '-' + h.slice(8, 12) + '-4' + h.slice(13, 16) + '-8' + h.slice(17, 20) + '-' + h.slice(20, 32)
35. }
37. static money = (n) => {
38. if (n == null) { return '$?' }
39. return '$' + n
40. }
42. // dollars rounded to 4 decimals (no Math in Hybriel: `%` does the floor)
43. static round4 = (x) => {
44. let n = x * 10000 + 0.5
45. n = n - (n % 1)
46. return n / 10000
47. }
49. // Claude's `--output-format json`: ONE result object, or (with `verbose` in the user's settings, as on
50. // Loreana) the whole message LIST whose `result` entry is the one we want → { result, mode, modes }
51. // `mode` = the permission mode Claude last reported (system init/status), null if not visible.
52. static claudeResult = (value) => {
53. if (isObject(value)) { return { result = value.type == 'result' ? value : null mode = null modes = [] } }
54. let result = null
55. let mode = null
56. let modes = []
57. if (isList(value)) {
58. for (m of value) {
59. if (isObject(m)) {
60. if (m.type == 'result') { result = m }
61. if (m.type == 'system' && m.permissionMode != null) {
62. mode = m.permissionMode
63. modes.push(m.subtype + ':' + m.permissionMode)
64. }
65. }
66. }
67. }
68. return { result = result mode = mode modes = modes }
69. }
71. // the USAGE line of one session (`label` e.g. 'USAGE' / 'CONTROLLER USAGE')
72. static usageLine = (label, res) => {
73. let u = res.usage == null ? {} : res.usage
74. let models = res.modelUsage == null ? [] : res.modelUsage.keys()
75. return label + ': ' + money(res.total_cost_usd) + ' · ' + res.num_turns + ' turns · ' + (res.duration_ms / 1000) + ' s · tokens in ' + u.input_tokens + ' / out ' + u.output_tokens + ' / cache read ' + u.cache_read_input_tokens + ' / cache write ' + u.cache_creation_input_tokens + ' · ' + models.join(', ') + ' · ' + res.subtype + ' · claude session ' + res.session_id
76. }
78. // after the exit: read the output file → { reason, res, cr, value }
79. // reason = why there is no usable result (null when `res` is there); who = 'worker' / 'controller'
80. static readClaude = (outFile, exit, timedOut, timeoutSeconds, who) => {
81. let reason = null
82. let res = null
83. let cr = null
84. let value = null
85. if (timedOut) { reason = 'timed out after ' + timeoutSeconds + ' s (killed)' }
86. if (!exists(outFile)) {
87. if (reason == null) { reason = 'no output from the ' + who + ' (exit ' + exit + ')' }
88. } else {
89. let rj = readJson(outFile)
90. if (rj.error != null) {
91. if (reason == null) { reason = 'the ' + who + ' output is not JSON (exit ' + exit + '): ' + rj.error }
92. } else {
93. value = rj.value
94. cr = claudeResult(rj.value)
95. res = cr.result
96. if (res == null && reason == null) { reason = 'no result in the ' + who + ' output (exit ' + exit + ')' }
97. }
98. }
99. return { reason = reason res = res cr = cr value = value }
100. }
102. // the usage part of a result, for session.json
103. static usageMeta = (res) => {
104. return { claudeSession = res.session_id subtype = res.subtype isError = res.is_error numTurns = res.num_turns durationMs = res.duration_ms costUsd = res.total_cost_usd usage = res.usage modelUsage = res.modelUsage permissionDenials = res.permission_denials }
105. }
107. // mission 026 (ticket antcolony#1 — the first live worker left two dev servers running on its ports): after a session
108. // part ended, stop what it left behind — every process LISTENING on a port of its range `ports` ('A-B') that STARTED
109. // after `since` (epoch ms), belongs to this user, is not the scheduler itself and carries no OTHER colony session in its
110. // environment (lib/cleanup.sh; never others). Prints `<label>: CLEANUP — stopped pid …` / `… skipped pid …` per process.
111. // Calls done(lines) — the script's lines except "nothing listening …" (for session.json). → the process or null
112. static cleanupPorts = (label, ports, since, session, done) => {
113. let home = env('COLONY_HOME')
114. let d = ports == null ? -1 : ports.indexOf('-')
115. if (home == null || home == '' || d <= 0) {
116. console.log(label + ': CLEANUP skipped — ' + (d <= 0 ? 'no port range' : 'COLONY_HOME is not set (run through ./colony)'))
117. done([])
118. return null
119. }
120. let out = []
121. let all = []
122. let q = spawnArgs(['bash' home + '/lib/cleanup.sh' ports.slice(0, d) ports.slice(d + 1) '' + since session])
123. on q.line(ev) {
124. let l = ev.stream == 'stderr' ? 'error: ' + ev.line : ev.line
125. if (l.trim() != '') {
126. all.push(l)
127. if (!l.startsWith('nothing listening')) { out.push(l) }
128. }
129. return null
130. }
131. on q.exit(ev) {
132. for (l of all) { console.log(label + ': CLEANUP — ' + l) }
133. done(out)
134. return null
135. }
136. return q
137. }
139. // runs `bin args…` in `o.folder` with `o.inFile` on stdin, stdout → o.outFile, stderr → o.errFile
140. // (umask 077, COLONY_TOKEN_FILE + COLONY_STOP_FILE unset, `o.env` entries set); kills it after o.timeout seconds; prints
141. // `<o.label>: TIMEOUT …`. Mission 026: with `o.session` + `o.ports` the child also gets COLONY_SESSION=<session>, and
142. // after its exit `cleanupPorts` stops what it left listening on its ports. Calls done({ ev, timedOut, lines, cleanup })
143. // once it has exited (and the cleanup is over). → the process
144. static runClaude = (o, done) => {
145. let script = 'umask 077; cd "$1" || { echo "colony: cannot cd to $1" >&2; exit 97; }; in=$2; out=$3; err=$4; shift 4; unset COLONY_TOKEN_FILE COLONY_STOP_FILE; exec "$@" <"$in" >"$out" 2>"$err"'
146. let name = 'colony-' + o.label
147. let cmd = ['sh' '-c' script name o.folder o.inFile o.outFile o.errFile]
148. // o.env (mission 020): 'NAME=value' entries for the child (e.g. its port range) — `env` execs the binary, same pid
149. let envs = []
150. if (o.env != null) { for (e of o.env) { envs.push(e) } }
151. let cleaning = o.session != null && o.session != '' && o.ports != null && o.ports != ''
152. if (cleaning) { envs.push('COLONY_SESSION=' + o.session) }
153. if (envs.length > 0) {
154. cmd.push('env')
155. for (e of envs) { cmd.push(e) }
156. }
157. // antcolony#18: o.sandbox = the bwrap argv prefix (sandbox.hl) — the session runs in the box; null / [] = host access
158. if (o.sandbox != null) { for (b of o.sandbox) { cmd.push(b) } }
159. cmd.push(o.bin)
160. for (a of o.args) { cmd.push(a) }
161. let lines = []
162. let timedOut = false
163. let since = now()
164. let p = spawnArgs(cmd)
165. let timer = after(toNumber(o.timeout))
166. on timer.tick(t) {
167. timedOut = true
168. console.log(o.label + ': TIMEOUT after ' + o.timeout + ' s — killing pid ' + p.pid)
169. p.kill()
170. return null
171. }
172. on p.line(ev) {
173. lines.push(ev.stream + ': ' + ev.line)
174. return null
175. }
176. on p.exit(ev) {
177. timer.stop()
178. if (!cleaning) {
179. done({ ev = ev lines = lines timedOut = timedOut cleanup = [] })
180. return null
181. }
182. cleanupPorts(o.label, o.ports, since, o.session, (cl) => {
183. done({ ev = ev lines = lines timedOut = timedOut cleanup = cl })
184. return null
185. })
186. return null
187. }
188. return p
189. }
191. // the environment of a session with a port range 'A-B' (mission 020: the agent hands each session its range)
192. static portEnv = (ports) => {
193. if (ports == null || ports == '') { return [] }
194. let d = ports.indexOf('-')
195. return ['COLONY_PORTS=' + ports 'COLONY_PORT_FROM=' + ports.slice(0, d) 'COLONY_PORT_TO=' + ports.slice(d + 1)]
196. }
198. // the last `rate_limit_event` of a verbose session output (Claude Code 2.1.280 sends one per API call:
199. // { status: allowed | allowed_warning | rejected, resetsAt (epoch s), rateLimitType, unifiedWindows:
200. // { five_hour: { utilization 0..1, resetsAt }, seven_day: … } }) → the rate_limit_info or null
201. static lastRateInfo = (value) => {
202. let info = null
203. if (isList(value)) {
204. for (m of value) { if (isObject(m) && m.type == 'rate_limit_event' && m.rate_limit_info != null) { info = m.rate_limit_info } }
205. }
206. return info
207. }
209. // mission 020: did the session end on the Claude usage / rate limit? → { limited, resetMs (null = unknown), text }
210. // Signals (any one): a `rate_limit_event` with status `rejected`; an error result with api_error_status 429;
211. // an error result whose text says so ("You've hit your limit …", "Claude AI usage limit reached|<epoch s>").
212. // Mission 034 (antcolony#25): the shape seen live 2026-09-25 (librarian call, Claude Code 2.1.280) — `rate_limit_event`
213. // rejected, then a SYNTHETIC assistant message with `error: "rate_limit"` + text "You've hit your session limit · resets
214. // 8:50pm (Europe/Vienna)", then a result with subtype `success` (!), is_error true, api_error_status 429, 0 tokens, $0.
215. // Also recognised: an assistant message with `error` "rate_limit" alone (its text is used), a 429 without is_error,
216. // and the words "session limit" / "weekly limit".
217. static rateLimitOf = (value, res) => {
218. let rejected = null
219. let apiLimit = false
220. let apiText = ''
221. if (isList(value)) {
222. for (m of value) {
223. if (isObject(m) && m.type == 'rate_limit_event' && m.rate_limit_info != null && m.rate_limit_info.status == 'rejected') { rejected = m.rate_limit_info }
224. if (isObject(m) && m.type == 'assistant' && m.error != null && ('' + m.error).toLowerCase().indexOf('rate_limit') >= 0) {
225. apiLimit = true
226. if (m.message != null && isList(m.message.content)) {
227. for (c of m.message.content) { if (apiText == '' && isObject(c) && c.type == 'text' && c.text != null) { apiText = '' + c.text } }
228. }
229. }
230. }
231. }
232. let text = ''
233. if (res != null && res.result != null && hlTypeName(res.result) == 'String') { text = res.result }
234. if (text == '') { text = apiText }
235. let limited = rejected != null || apiLimit
236. if (res != null && res.api_error_status == 429) { limited = true }
237. if (res != null && (res.is_error == true || apiLimit)) {
238. let low = text.toLowerCase()
239. if (low.indexOf('limit') >= 0 && (low.indexOf('hit your') >= 0 || low.indexOf('usage limit') >= 0 || low.indexOf('session limit') >= 0 || low.indexOf('weekly limit') >= 0 || low.indexOf('rate limit') >= 0 || low.indexOf('rate_limit') >= 0)) { limited = true }
240. }
241. let resetMs = null
242. if (rejected != null && rejected.resetsAt != null) { resetMs = rejected.resetsAt * 1000 }
243. if (resetMs == null && limited) {
244. let bar = text.lastIndexOf('|')
245. if (bar >= 0) {
246. let n = toNumber(text.slice(bar + 1).trim())
247. if (n != null && n > 1000000000) { resetMs = n * 1000 }
248. }
249. }
250. if (text == '' && rejected != null) { text = 'rate_limit_event rejected (' + rejected.rateLimitType + ')' }
251. return { limited = limited resetMs = resetMs text = text }
252. }