@dirwin517/bot-farm 0.1.0

package/src/ws.mjs

@@ -0,0 +1,130 @@
+// A small RFC 6455 server, text frames only, no dependencies.
+//
+// The dashboard already received pushes over SSE rather than polling, but a
+// websocket is cheaper per message (2–10 bytes of framing against SSE's
+// "data: " plus base64-free UTF-8 reparse), survives proxies that buffer
+// event-streams, and gives the client a way to talk back — used here for
+// nothing more than pings and a "send me everything again" resync.
+//
+// Actions stay on plain HTTP. They are one-shot, they want status codes and
+// retries, and multiplexing them over a socket would mean inventing request
+// ids and error plumbing that fetch already has.
+
+import { createHash, randomBytes } from "node:crypto"
+
+const MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+export function isWebSocketUpgrade(req) {
+  return (
+    req.headers.upgrade?.toLowerCase() === "websocket" &&
+    /\bupgrade\b/i.test(req.headers.connection ?? "") &&
+    !!req.headers["sec-websocket-key"]
+  )
+}
+
+export function accept(req, socket, { onMessage = () => {}, onClose = () => {} } = {}) {
+  const key = req.headers["sec-websocket-key"]
+  const digest = createHash("sha1").update(key + MAGIC).digest("base64")
+  socket.write(
+    "HTTP/1.1 101 Switching Protocols\r\n" +
+      "Upgrade: websocket\r\n" +
+      "Connection: Upgrade\r\n" +
+      `Sec-WebSocket-Accept: ${digest}\r\n\r\n`,
+  )
+  socket.setNoDelay(true)
+
+  const conn = new Connection(socket)
+  let buffer = Buffer.alloc(0)
+
+  socket.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk])
+    while (true) {
+      const frame = decode(buffer)
+      if (!frame) break
+      buffer = buffer.subarray(frame.size)
+      if (frame.opcode === 0x8) return conn.close()
+      if (frame.opcode === 0x9) { socket.write(encode(frame.payload, 0xa)); continue }
+      if (frame.opcode === 0xa) { conn.alive = true; continue }
+      if (frame.opcode === 0x1) onMessage(frame.payload.toString("utf8"), conn)
+    }
+  })
+  socket.on("error", () => conn.close())
+  socket.on("close", () => { conn.open = false; onClose(conn) })
+  return conn
+}
+
+class Connection {
+  constructor(socket) {
+    this.socket = socket
+    this.open = true
+    this.alive = true
+    this.id = randomBytes(6).toString("hex")
+    // A half-open socket looks identical to a quiet one until you ping it.
+    this.heartbeat = setInterval(() => {
+      if (!this.open) return
+      if (!this.alive) return this.close()
+      this.alive = false
+      try { this.socket.write(encode(Buffer.alloc(0), 0x9)) } catch { this.close() }
+    }, 20000)
+  }
+  send(text) {
+    if (!this.open) return false
+    try {
+      this.socket.write(encode(Buffer.from(text, "utf8"), 0x1))
+      return true
+    } catch {
+      this.close()
+      return false
+    }
+  }
+  close() {
+    if (!this.open) return
+    this.open = false
+    clearInterval(this.heartbeat)
+    try { this.socket.end(encode(Buffer.alloc(0), 0x8)) } catch {}
+    try { this.socket.destroy() } catch {}
+  }
+}
+
+function encode(payload, opcode = 0x1) {
+  const len = payload.length
+  let header
+  if (len < 126) {
+    header = Buffer.alloc(2)
+    header[1] = len
+  } else if (len < 65536) {
+    header = Buffer.alloc(4)
+    header[1] = 126
+    header.writeUInt16BE(len, 2)
+  } else {
+    header = Buffer.alloc(10)
+    header[1] = 127
+    header.writeBigUInt64BE(BigInt(len), 2)
+  }
+  header[0] = 0x80 | opcode // FIN + opcode; server frames are never masked
+  return Buffer.concat([header, payload])
+}
+
+/** Returns null until a whole frame is buffered. */
+function decode(buf) {
+  if (buf.length < 2) return null
+  const opcode = buf[0] & 0x0f
+  const masked = (buf[1] & 0x80) !== 0
+  let len = buf[1] & 0x7f
+  let offset = 2
+  if (len === 126) {
+    if (buf.length < 4) return null
+    len = buf.readUInt16BE(2)
+    offset = 4
+  } else if (len === 127) {
+    if (buf.length < 10) return null
+    len = Number(buf.readBigUInt64BE(2))
+    offset = 10
+  }
+  const maskKey = masked ? buf.subarray(offset, offset + 4) : null
+  if (masked) offset += 4
+  if (buf.length < offset + len) return null
+  const payload = Buffer.from(buf.subarray(offset, offset + len))
+  if (maskKey) for (let i = 0; i < payload.length; i++) payload[i] ^= maskKey[i % 4]
+  return { opcode, payload, size: offset + len }
+}

package/src/yaml.mjs

@@ -0,0 +1,266 @@
+// A deliberately small YAML subset — enough for personas and pipelines, and
+// nothing more. Supported: comments, nested maps by indentation, "- " lists
+// (of scalars or maps), quoted and bare scalars, numbers, booleans, null, and
+// the "|" / ">" block scalars that prompts need.
+//
+// Not supported: anchors, aliases, multiple documents, flow maps, tags. If a
+// file uses them, parsing throws with a line number rather than silently
+// producing something odd — these files are edited by hand, so a loud failure
+// beats a quiet misreading.
+
+export function parse(text) {
+  const lines = String(text).split(/\r?\n/)
+  const root = {}
+  const stack = [{ indent: -1, value: root }]
+  let i = 0
+
+  const fail = (msg) => {
+    throw new Error(`${msg} (line ${i + 1}: ${lines[i]?.trim()})`)
+  }
+
+  while (i < lines.length) {
+    const raw = lines[i]
+    const line = stripComment(raw)
+    if (!line.trim()) { i++; continue }
+    if (/^\s*(---|\.\.\.)\s*$/.test(line)) { i++; continue }
+    if (/[&*!]\S/.test(line.trim()) && /^\s*\w+:\s*[&*]/.test(line)) fail("anchors and aliases are not supported")
+
+    const indent = line.match(/^ */)[0].length
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) stack.pop()
+    const parent = stack[stack.length - 1].value
+    const body = line.slice(indent)
+
+    // list item
+    if (body.startsWith("- ") || body === "-") {
+      if (!Array.isArray(parent)) fail("list item outside a list")
+      const rest = body.slice(2)
+      if (!rest.trim()) {
+        const obj = {}
+        parent.push(obj)
+        stack.push({ indent, value: obj })
+        i++
+        continue
+      }
+      const kv = splitKey(rest)
+      if (kv) {
+        const obj = {}
+        parent.push(obj)
+        stack.push({ indent, value: obj })
+        // re-handle the inline "key: value" at a deeper virtual indent
+        const [key, value] = kv
+        const block = readBlock(value, indent + 2)
+        if (block !== undefined) obj[key] = block
+        else if (value === "") {
+          const child = nextIsList(indent + 2) ? [] : {}
+          obj[key] = child
+          stack.push({ indent: indent + 1, value: child })
+        } else obj[key] = scalar(value)
+        i++
+        continue
+      }
+      parent.push(scalar(rest))
+      i++
+      continue
+    }
+
+    // key: value
+    const kv = splitKey(body)
+    if (!kv) fail("expected 'key: value' or '- item'")
+    const [key, value] = kv
+    if (Array.isArray(parent)) fail("mapping inside a list needs '- ' on its first key")
+
+    const block = readBlock(value, indent)
+    if (block !== undefined) {
+      parent[key] = block
+      continue // readBlock advanced i
+    }
+    if (value === "") {
+      const child = nextIsList(indent) ? [] : {}
+      parent[key] = child
+      stack.push({ indent, value: child })
+      i++
+      continue
+    }
+    parent[key] = scalar(value)
+    i++
+  }
+  return root
+
+  /** Look ahead past blanks for the next meaningful line's shape. */
+  function nextIsList(indent) {
+    for (let j = i + 1; j < lines.length; j++) {
+      const l = stripComment(lines[j])
+      if (!l.trim()) continue
+      const ind = l.match(/^ */)[0].length
+      if (ind <= indent) return false
+      return l.slice(ind).startsWith("- ") || l.slice(ind) === "-"
+    }
+    return false
+  }
+
+  /** "|" and ">" block scalars; returns undefined when `value` isn't one. */
+  function readBlock(value, indent) {
+    const m = /^([|>])([-+]?)$/.exec(value.trim())
+    if (!m) return undefined
+    const fold = m[1] === ">"
+    const chomp = m[2]
+    const out = []
+    let j = i + 1
+    let blockIndent = null
+    for (; j < lines.length; j++) {
+      const l = lines[j]
+      if (!l.trim()) { out.push(""); continue }
+      const ind = l.match(/^ */)[0].length
+      if (ind <= indent) break
+      if (blockIndent === null) blockIndent = ind
+      out.push(l.slice(blockIndent))
+    }
+    i = j
+    while (out.length && out[out.length - 1] === "") out.pop()
+    let text = fold ? foldLines(out) : out.join("\n")
+    if (chomp !== "-") text += "\n"
+    if (chomp === "-") text = text.replace(/\n+$/, "")
+    return text
+  }
+}
+
+function foldLines(lines) {
+  const out = []
+  for (const l of lines) {
+    if (l === "") out.push("\n")
+    else if (out.length && !out[out.length - 1].endsWith("\n")) out[out.length - 1] += " " + l
+    else out.push(l)
+  }
+  return out.join("").replace(/\n(?!\n)/g, "\n")
+}
+
+function stripComment(line) {
+  let out = ""
+  let quote = null
+  for (let k = 0; k < line.length; k++) {
+    const c = line[k]
+    if (quote) {
+      out += c
+      if (c === quote && line[k - 1] !== "\\") quote = null
+      continue
+    }
+    if (c === '"' || c === "'") { quote = c; out += c; continue }
+    if (c === "#" && (k === 0 || /\s/.test(line[k - 1]))) break
+    out += c
+  }
+  return out.replace(/\s+$/, "")
+}
+
+function splitKey(body) {
+  let quote = null
+  for (let k = 0; k < body.length; k++) {
+    const c = body[k]
+    if (quote) { if (c === quote) quote = null; continue }
+    if (c === '"' || c === "'") { quote = c; continue }
+    if (c === ":" && (k + 1 === body.length || /\s/.test(body[k + 1]))) {
+      return [unquote(body.slice(0, k).trim()), body.slice(k + 1).trim()]
+    }
+  }
+  return null
+}
+
+function unquote(s) {
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1).replace(/\\n/g, "\n").replace(/\\"/g, '"')
+  }
+  return s
+}
+
+function scalar(v) {
+  const s = v.trim()
+  if (s === "" || s === "~" || s === "null") return null
+  if (s === "true" || s === "yes") return true
+  if (s === "false" || s === "no") return false
+  if (/^-?\d+$/.test(s)) return Number(s)
+  if (/^-?\d*\.\d+$/.test(s)) return Number(s)
+  if (s.startsWith("[") && s.endsWith("]")) {
+    const inner = s.slice(1, -1).trim()
+    return inner ? splitFlow(inner).map((x) => scalar(x)) : []
+  }
+  // One-line maps: { usd: 5, per: day }. Not "{{story}}" — that is a template.
+  if (s.startsWith("{") && s.endsWith("}") && s[1] !== "{") {
+    const inner = s.slice(1, -1).trim()
+    if (!inner) return {}
+    const pairs = splitFlow(inner).map((x) => splitKey(x.trim()) ?? (/^[\w-]+:$/.test(x.trim()) ? [x.trim().slice(0, -1), ""] : null))
+    if (pairs.every(Boolean)) return Object.fromEntries(pairs.map(([k, v]) => [k, scalar(v)]))
+  }
+  return unquote(s)
+}
+
+/** Split on top-level commas, leaving nested [], {} and quotes alone. */
+function splitFlow(s) {
+  const out = []
+  let depth = 0, quote = null, start = 0
+  for (let k = 0; k < s.length; k++) {
+    const c = s[k]
+    if (quote) { if (c === quote && s[k - 1] !== "\\") quote = null; continue }
+    if (c === '"' || c === "'") quote = c
+    else if (c === "[" || c === "{") depth++
+    else if (c === "]" || c === "}") depth--
+    else if (c === "," && depth === 0) { out.push(s.slice(start, k)); start = k + 1 }
+  }
+  out.push(s.slice(start))
+  return out.map((x) => x.trim()).filter((x) => x !== "")
+}
+
+// --------------------------------------------------------------------------
+
+export function stringify(value, indent = 0) {
+  const pad = " ".repeat(indent)
+  if (value === null || value === undefined) return "null"
+  if (Array.isArray(value)) {
+    if (!value.length) return "[]"
+    return value
+      .map((v) =>
+        isPlainObject(v)
+          ? listItem(v, indent, pad)
+          : `${pad}- ${scalarOut(v)}`,
+      )
+      .join("\n")
+  }
+  if (isPlainObject(value)) {
+    return Object.entries(value)
+      .map(([k, v]) => {
+        if (isPlainObject(v)) {
+          return Object.keys(v).length ? `${pad}${k}:\n${stringify(v, indent + 2)}` : `${pad}${k}: {}`
+        }
+        if (Array.isArray(v)) {
+          return v.length ? `${pad}${k}:\n${stringify(v, indent + 2)}` : `${pad}${k}: []`
+        }
+        if (typeof v === "string" && v.includes("\n")) {
+          const body = v.replace(/\n$/, "").split("\n").map((l) => " ".repeat(indent + 2) + l).join("\n")
+          return `${pad}${k}: |\n${body}`
+        }
+        return `${pad}${k}: ${scalarOut(v)}`
+      })
+      .join("\n")
+  }
+  return `${pad}${scalarOut(value)}`
+}
+
+// "- key: value" with the rest of the map under it. The first key must be a
+// scalar, so move one to the front; a map with none uses a bare "-" line.
+function listItem(v, indent, pad) {
+  const keys = Object.keys(v)
+  const scalar = keys.find((k) => !isPlainObject(v[k]) && !Array.isArray(v[k]) && !(typeof v[k] === "string" && v[k].includes("\n")))
+  if (scalar === undefined) return `${pad}-\n${stringify(v, indent + 2)}`
+  const ordered = { [scalar]: v[scalar], ...v }
+  return `${pad}- ${stringify(ordered, indent + 2).slice(indent + 2)}`
+}
+
+const isPlainObject = (v) => v && typeof v === "object" && !Array.isArray(v)
+
+function scalarOut(v) {
+  if (v === null || v === undefined) return "null"
+  if (typeof v === "boolean" || typeof v === "number") return String(v)
+  const s = String(v)
+  if (s === "" || /^[\s#&*!|>%@`]/.test(s) || /:\s/.test(s) || /^(true|false|null|yes|no|~|-?\d+(\.\d+)?)$/.test(s)) {
+    return JSON.stringify(s)
+  }
+  return s
+}

package/test/board.mjs

@@ -0,0 +1,108 @@
+// The board is a registry, not a listing: ownership, groups, cost, tools.
+import { spawn as spawnProc } from "node:child_process"
+import { Supervisor } from "../src/supervisor.mjs"
+import { startServer } from "../src/server.mjs"
+import { estimate, normalise, rateFor } from "../src/pricing.mjs"
+import { handleFor, avatarFor, GLYPH } from "../src/identity.mjs"
+
+const mock = spawnProc(process.execPath, [new URL("./mock-opencode.mjs", import.meta.url).pathname], { stdio: "ignore" })
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+let failed = 0
+const ok = (c, m) => (c ? console.log("  ok  " + m) : (failed++, console.error("  FAIL " + m)))
+
+console.log("identities")
+ok(GLYPH.size >= 64, `the creature roster is ${GLYPH.size} strong`)
+ok(new Set(GLYPH.values()).size === GLYPH.size, "every creature has its own glyph — no two share a face")
+const taken = new Set()
+const creatures = new Set()
+for (let i = 0; i < 300; i++) {
+  const h = handleFor("ses_test_" + i, taken)
+  taken.add(h)
+  creatures.add(h.split("-").slice(1).join("-"))
+}
+ok(taken.size === 300, "300 sessions get 300 distinct handles")
+ok(creatures.size > 40, `spread across ${creatures.size} different creatures`)
+const svg = avatarFor("ses_test_1", { handle: [...taken][0] })
+ok(/viewBox="0 0 32 32"/.test(svg) && /<text/.test(svg), "and each renders as a glyph avatar")
+ok(avatarFor("x", { handle: "brisk-otter" }) === avatarFor("x", { handle: "brisk-otter" }), "deterministic across calls")
+
+console.log("\npricing")
+ok(normalise("us.anthropic.claude-sonnet-4-20250514-v1:0") === "claude-sonnet-4", "a Bedrock id normalises to its family")
+ok(normalise("anthropic/claude-opus-4-1-20250805") === "claude-opus-4-1", "a provider-prefixed id normalises too")
+ok(rateFor("us.anthropic.claude-sonnet-4-20250514-v1:0")?.input === 3, "and finds a rate")
+const bedrock = estimate({
+  model: "us.anthropic.claude-sonnet-4-20250514-v1:0",
+  totals: { input: 100_000, output: 20_000, cacheRead: 1_000_000, cacheWrite: 50_000 },
+  reported: 0,
+})
+ok(bedrock.usd > 0 && bedrock.estimated, `Bedrock sessions get a price anyway ($${bedrock.usd.toFixed(3)})`)
+ok(Math.abs(bedrock.usd - (0.3 + 0.3 + 0.3 + 0.1875)) < 0.01, "cache reads are a tenth and writes a quarter more")
+ok(estimate({ model: "x", totals: {}, reported: 4.2 }).estimated === false, "a reported cost is used as-is")
+ok(estimate({ model: "some-new-model", totals: { input: 5 } }).unknownModel === "some-new-model", "an unpriced model says so rather than guessing")
+ok(estimate({ model: "gpt-4o", totals: { input: 1e6 }, overrides: { "gpt-4o": { input: 99, output: 1 } } }).usd === 99, "config overrides win")
+
+await sleep(600)
+const sup = new Supervisor({
+  url: "http://127.0.0.1:4096",
+  statePath: "/tmp/botfarm-reg-state-" + Date.now() + ".json",
+  registryPath: "/tmp/botfarm-reg-" + Date.now() + ".json",
+  mcpBase: "http://127.0.0.1:4795",
+})
+await sup.start()
+const { url } = startServer({ supervisor: sup, port: 4795 })
+const get = async (p) => (await fetch(url + p)).json()
+const post = async (p, body) =>
+  (await fetch(url + p, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body ?? {}) })).json()
+
+console.log("\nan empty board")
+let state = await get("/api/state")
+ok(state.sessions.length === 0, "sessions opencode knows about do not appear on their own")
+ok(state.unmanaged === 2, `they are offered instead (${state.unmanaged} available)`)
+let loose = await get("/api/unmanaged")
+ok(loose.sessions.length === 2 && loose.sessions[0].title, "the adoption list carries enough to choose by")
+ok((await get("/api/unmanaged?q=flaky")).sessions.length === 1, "the list is searchable")
+
+console.log("\nadopting")
+await post("/api/adopt", { ids: [loose.sessions[0].id], project: "auth-work" })
+await sleep(1400)
+state = await get("/api/state")
+ok(state.sessions.length === 1, "only the adopted session is on the board")
+ok(state.unmanaged === 1, "the rest stay out of the way")
+ok(state.projects.some((p) => p.id === "auth-work"), "the project is created and counted")
+ok(!!state.sessions[0].handle, `it gets an identity (@${state.sessions[0].handle})`)
+
+console.log("\ncost on a card")
+const adopted = state.sessions[0]
+ok(adopted.cost && typeof adopted.cost.usd === "number", "every card carries a cost")
+const detail = await get(`/api/sessions/${adopted.id}`)
+ok(detail.cost.estimated === true, "which is marked as an estimate when the provider gave us none")
+
+console.log("\nlast message on the card")
+ok(typeof adopted.lastText === "string" && adopted.lastText.length > 0, `the card shows what you would be continuing ("${adopted.lastText.slice(0, 40)}…")`)
+
+console.log("\ntools")
+ok(detail.tools.servers.length === 2, `MCP servers are listed (${detail.tools.servers.map((s) => s.name).join(", ")})`)
+ok(detail.tools.servers.find((s) => s.name === "playwright")?.connected === false, "with their connection state")
+ok(detail.tools.builtin.length > 0 && detail.tools.builtin.every((t) => t.enabled), "built-in tools start enabled")
+await post(`/api/sessions/${adopted.id}/tools`, { name: "bash", enabled: false })
+const after = await get(`/api/sessions/${adopted.id}`)
+ok(after.tools.builtin.find((t) => t.name === "bash")?.enabled === false, "a tool can be switched off")
+ok((await post(`/api/sessions/${adopted.id}/mcp`, { name: "playwright", connected: true })).ok, "an MCP server can be connected")
+
+console.log("\ngroups and release")
+await post(`/api/sessions/${adopted.id}/group`, { project: "default" })
+state = await get("/api/state")
+ok(state.sessions[0].project === "default", "a session can be moved between projects")
+await post(`/api/sessions/${adopted.id}/release`, {})
+state = await get("/api/state")
+ok(state.sessions.length === 0 && state.unmanaged === 2, "releasing puts it back in the pool without deleting it")
+
+console.log("\nrestart")
+await sup.registry.load()
+const reopened = sup.projects.get("auth-work")
+ok(!!reopened && reopened.name === "auth-work", "the project itself outlives the sessions in it")
+
+await sup.stop()
+mock.kill()
+console.log(failed ? `\n${failed} CHECKS FAILED` : "\nall checks passed")
+process.exit(failed ? 1 : 0)