@dirwin517/bot-farm 0.1.0

package/test/roles.mjs

@@ -0,0 +1,157 @@
+// Who a bot is (its name), who owns a task (a session, a part, or you), and
+// whether a pipeline can be edited without leaving the app.
+import { spawn as spawnProc, execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { mkdtemp, writeFile, readFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { Supervisor } from "../src/supervisor.mjs"
+import { startServer } from "../src/server.mjs"
+import { handleFor, adjectivesFor } from "../src/identity.mjs"
+import * as YAML from "../src/yaml.mjs"
+
+const run = promisify(execFile)
+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("names carry the job")
+ok(adjectivesFor("qa").includes("prying"), "a tester draws from a suspicious vocabulary")
+ok(adjectivesFor("dev").includes("polishing"), "a builder from a making one")
+ok(adjectivesFor("product").includes("framing"), "product from a shaping one")
+ok(adjectivesFor(null).includes("brisk"), "anything else falls back to the generic list")
+ok(adjectivesFor("qa", ["grumpy"])[0] === "grumpy", "a persona can bring its own words")
+const taken = new Set()
+const qa = handleFor("ses_q", taken, { role: "qa" })
+const dev = handleFor("ses_d", taken, { role: "dev" })
+ok(adjectivesFor("qa").includes(qa.split("-")[0]), `a QA session is named like one (@${qa})`)
+ok(adjectivesFor("dev").includes(dev.split("-")[0]), `and a dev session like one (@${dev})`)
+ok(handleFor("ses_q", new Set(), { role: "qa" }) === qa, "and the name is stable")
+
+const repo = await mkdtemp(join(tmpdir(), "roles-"))
+await run("git", ["init", "-q", "-b", "main"], { cwd: repo })
+await writeFile(join(repo, "README.md"), "# demo\n")
+await run("git", ["add", "."], { cwd: repo })
+await run("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "-qm", "i"], { cwd: repo })
+const home = await mkdtemp(join(tmpdir(), "roleshome-"))
+
+await sleep(600)
+const sup = new Supervisor({
+  url: "http://127.0.0.1:4096",
+  statePath: join(home, "m.json"),
+  registryPath: join(home, "r.json"),
+  mcpBase: "http://127.0.0.1:4807",
+})
+await sup.start()
+startServer({ supervisor: sup, port: 4807 })
+const api = async (p, opts = {}) =>
+  (await fetch("http://127.0.0.1:4807" + p, {
+    method: opts.method ?? "GET",
+    headers: opts.body ? { "content-type": "application/json" } : undefined,
+    body: opts.body ? JSON.stringify(opts.body) : undefined,
+  })).json()
+
+const r = await sup.pipelines.start({ pipeline: "story", repo, branch: "feat/x", story: "Something is wrong with login.", title: "Login" })
+await sleep(500)
+
+console.log("\nthe crew is named for what it does")
+const named = Object.entries(r.sessions).map(([persona, id]) => [persona, sup.store.get(id).handle])
+for (const [persona, handle] of named) {
+  ok(adjectivesFor(persona).includes(handle.split("-")[0]), `${persona} → @${handle}`)
+}
+ok(new Set(named.map(([, h]) => h)).size === named.length, "and no two share a name")
+
+console.log("\ntasks belong to a part, not only to one session")
+const buildTask = sup.tasks.get(r.taskIds.build)
+ok(buildTask.role === "dev", "a stage task records the part that owns it")
+ok(buildTask.owner === "session", "as well as the session currently playing it")
+const loose = sup.tasks.create({ title: "Fix the flake", brief: "x", role: "qa", owner: "role", projectId: r.projectId })
+ok(loose.status === "queued" && !loose.assignee, "work can be addressed to a part with nobody named")
+const qaSession = sup.store.get(r.sessions.qa)
+qaSession.setStatus("idle")
+await sup.pipelines.dispatch()
+const claimed = sup.tasks.get(loose.id)
+ok(claimed.assignee === qaSession.id, "whoever is playing that part picks it up")
+ok(claimed.status === "active", "and it becomes theirs, so a second bot cannot take it too")
+
+console.log("\nthe human is an assignee too")
+const rpc = (session) => {
+  const url = sup.mcpUrlFor(session)
+  let id = 0
+  return async (name, args = {}) => {
+    // Every bot in a run shares one worktree, and opencode keeps one MCP URL
+    // per worktree, so the URL alone cannot say who is calling. In real use
+    // the event stream announces the botfarm_ tool starting; stand in for that.
+    sup.mcpCalls.set(session.id, Date.now())
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: ++id, method: "tools/call", params: { name, arguments: args } }),
+    })
+    const out = (await res.json()).result
+    return { isError: !!out.isError, data: out.structuredContent, text: out.content[0].text }
+  }
+}
+const dev2 = sup.store.get(r.sessions.dev)
+const callDev = rpc(dev2)
+let out = await callDev("ask_human", {
+  question: "Should the return path survive a second SSO hop, or is one enough?",
+  options: ["one hop is enough", "must survive any number"],
+})
+ok(!out.isError && out.data.asked, "a bot can ask its operator directly")
+const question = sup.tasks.get(out.data.task_id)
+ok(question.owner === "human" && question.kind === "question", "which lands as a human-owned question")
+ok(question.status === "waiting", "waiting, not queued — nothing dispatches it")
+ok(question.options.length === 2, "with the choices it offered")
+ok(sup.tasks.forHuman().some((t) => t.id === question.id), "and it surfaces in what needs you")
+
+out = await callDev("tasks")
+ok(out.data.yours.some((t) => t.id === question.id), "the asker can see it is still open")
+
+await api(`/api/tasks/${question.id}/answer`, { method: "POST", body: { answer: "One hop is enough." } })
+await sleep(300)
+const answered = sup.tasks.get(question.id)
+ok(answered.status === "done" && answered.answer === "One hop is enough.", "answering closes it")
+const devMsgs = (await sup.client.messages(dev2.id, { limit: 20 })).flatMap((m) => (m.parts ?? []).map((p) => p.text ?? ""))
+ok(devMsgs.some((t) => t.includes("your operator answered")), "and the answer goes back to the bot that asked")
+ok(devMsgs.some((t) => t.includes("came from the human running this session")), "marked as coming from you, not from a peer")
+
+console.log("\na pipeline can have a stage that is yours")
+const story = sup.pipelines.definitions.get("story")
+ok(story.stages.some((st) => st.human), "the shipped pipeline ends with a human sign-off")
+const signoff = sup.tasks.all({ runId: r.id }).find((t) => t.stage === "signoff")
+ok(signoff?.owner === "human", "which becomes a task for you when its turn comes")
+ok(!signoff.assignee, "never dispatched to a bot")
+
+console.log("\nediting definitions")
+const def = await api("/api/pipelines/story")
+ok(def.doc.stages.length === 5 && def.yaml.includes("stages:"), "a definition can be read back as structure and as YAML")
+const edited = structuredClone(def.doc)
+edited.stages.splice(1, 0, { id: "spike", persona: "dev", title: "Spike it first", receives: ["analyse"], prompt: "Try it roughly: {{story}}" })
+let saved = await api("/api/pipelines/story", { method: "PUT", body: { doc: edited } })
+ok(saved.problems.length === 0, "a stage can be inserted")
+ok(sup.pipelines.definitions.get("story").stages.length === 6, "and takes effect without a restart")
+const onDisk = YAML.parse(await readFile(join(home, "pipelines", "story.yaml"), "utf8"))
+ok(onDisk.stages[1].id === "spike", "written back to the YAML file, still yours to diff and commit")
+
+const broken = structuredClone(edited)
+broken.stages[2].receives = ["nope"]
+saved = await api("/api/pipelines/story", { method: "PUT", body: { doc: broken } })
+ok(saved.problems.some((p) => p.includes("nope")), "a stage receiving something that does not exist is reported, not swallowed")
+
+const persona = await api("/api/personas/qa")
+const pdoc = { ...persona.doc, model: "anthropic/claude-haiku-4-5", tools: ["read", "grep", "bash"], adjectives: ["grumpy", "dubious"] }
+saved = await api("/api/personas/qa", { method: "PUT", body: { doc: pdoc } })
+ok(saved.problems.length === 0, "a persona's model, tools and vocabulary can be changed")
+ok(sup.pipelines.personas.get("qa").model === "anthropic/claude-haiku-4-5", "and is live immediately")
+const fresh = handleFor("ses_new_qa", new Set(), {
+  role: "qa",
+  adjectives: sup.pipelines.personas.get("qa").adjectives,
+})
+ok(fresh.startsWith("grumpy") || fresh.startsWith("dubious"), `so the next tester is named from it (@${fresh})`)
+
+await sup.stop()
+mock.kill()
+console.log(failed ? `\n${failed} CHECKS FAILED` : "\nall checks passed")
+process.exit(failed ? 1 : 0)

package/test/shot.mjs

@@ -0,0 +1,65 @@
+import { spawn } from "node:child_process"
+import { createRequire } from "node:module"
+import { Supervisor } from "../src/supervisor.mjs"
+import { startServer } from "../src/server.mjs"
+
+const require = createRequire("/home/claude/.npm-global/lib/node_modules/@mermaid-js/mermaid-cli/")
+const puppeteer = require("puppeteer")
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+const mock = spawn(process.execPath, [new URL("./mock-opencode.mjs", import.meta.url).pathname], { stdio: "ignore" })
+await sleep(700)
+const sup = new Supervisor({ url: "http://127.0.0.1:4096", statePath: "/tmp/botfarm-shot-" + Date.now() + ".json", registryPath: "/tmp/botfarm-reg-" + Math.random().toString(36).slice(2) + ".json" })
+await sup.start()
+const { url } = startServer({ supervisor: sup, port: 4799 })
+// the board only shows sessions botfarm manages, so adopt the mock's two first
+await sup.adopt(sup.unmanaged.map((x) => x.id))
+await sleep(2500)
+// light the mesh up so the screenshot shows handles, mail and policy controls
+const [a, b] = sup.store.list()
+await sup.setPolicy(a.id, { talk: "open", spawn: true })
+await sup.setPolicy(b.id, { talk: "open" })
+await sup.mesh.send(a, b.handle, "The auth middleware I touched also gates /health — check before you change it.")
+for (const s2 of [a, b]) await sup.setPolicy(s2.id, { rooms: "create" })
+const room = sup.rooms.create({ name: "auth refactor", topic: "Splitting session auth out of the monolith", members: [a, b] })
+await sup.rooms.post(room, a, "Moved the token parser to packages/auth. Nothing else touched yet.")
+await sup.rooms.post(room, null, `Ship that first, leave the cookie bug to @${b.handle}`)
+await sleep(1200)
+
+const browser = await puppeteer.launch({ args: ["--no-sandbox"], executablePath: process.env.CHROME_PATH || undefined })
+const page = await browser.newPage()
+await page.setViewport({ width: 1440, height: 980, deviceScaleFactor: 2 })
+const errors = []
+page.on("pageerror", (e) => errors.push(String(e)))
+page.on("console", (m) => m.type() === "error" && errors.push(m.text()))
+await page.goto(url, { waitUntil: "domcontentloaded" })
+await sleep(2500)
+await page.screenshot({ path: "/tmp/dash.png" })
+
+const cards = await page.$$eval(".pod", (els) =>
+  els.map((e) => ({
+    status: e.dataset.status,
+    name: e.querySelector(".name").textContent,
+    tpm: e.querySelector(".tpm").textContent,
+    paths: e.querySelectorAll("svg.spark path").length,
+  })),
+)
+console.log("cards:", JSON.stringify(cards))
+console.log("errors:", errors.slice(0, 5))
+
+await page.click(".navitem[data-k=\"room\"]")
+await sleep(1000)
+await page.screenshot({ path: "/tmp/room.png" })
+console.log("room view:", await page.$$eval(".chat .turn .m", (e) => e.map((x) => x.textContent)))
+await page.click("#rm-close")
+await sleep(400)
+await page.click(".pod .open")
+await sleep(1200)
+await page.screenshot({ path: "/tmp/inspector.png" })
+console.log("side sections:", await page.$$eval(".modal .side h3", (e) => e.map((x) => x.textContent)))
+console.log("errors2:", errors.slice(0, 5))
+
+await browser.close()
+await sup.stop()
+mock.kill()
+process.exit(0)

package/test/smoke.mjs

@@ -0,0 +1,70 @@
+// End-to-end smoke test: mock opencode -> supervisor -> dashboard API.
+import { spawn } from "node:child_process"
+import { Supervisor } from "../src/supervisor.mjs"
+import { startServer } from "../src/server.mjs"
+
+const mock = spawn(process.execPath, [new URL("./mock-opencode.mjs", import.meta.url).pathname], { stdio: "ignore" })
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+const fail = (m) => { console.error("FAIL:", m); process.exitCode = 1 }
+const ok = (c, m) => (c ? console.log("  ok  " + m) : fail(m))
+
+await sleep(600)
+const sup = new Supervisor({ url: "http://127.0.0.1:4096", statePath: "/tmp/botfarm-test-" + Date.now() + ".json", registryPath: "/tmp/botfarm-reg-" + Math.random().toString(36).slice(2) + ".json" })
+await sup.start()
+const { url } = startServer({ supervisor: sup, port: 4788 })
+const get = async (p, o) => (await fetch(url + p, o)).json()
+
+// the board only shows sessions botfarm manages, so adopt the mock's two first
+await sup.adopt(sup.unmanaged.map((x) => x.id))
+await sleep(2600)
+let state = await get("/api/state")
+console.log("\nstate after 7s")
+ok(state.sessions.length === 2, "two sessions discovered")
+ok(state.totals.busy === 1, "one session reported busy")
+const busy = state.sessions.find((s) => s.status === "busy")
+ok(busy.tokPerMin > 0, `token rate is live (${busy.tokPerMin}/min)`)
+ok(busy.totals.tools > 0, `tool calls counted (${busy.totals.tools})`)
+ok(busy.spark.tok.length === 60 && busy.spark.tok.at(-1) > 0, "sparkline has 60 buckets with a live tail")
+ok(busy.contextTokens > 0, `context tokens tracked (${busy.contextTokens})`)
+ok(!!busy.lastText, "latest assistant text captured")
+
+const idle = state.sessions.find((s) => s.status === "idle")
+console.log("\nsend a prompt to the idle session")
+await fetch(`${url}/api/sessions/${idle.id}/send`, {
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify({ text: "continue" }),
+})
+await sleep(1800)
+state = await get("/api/state")
+const woken = state.sessions.find((s) => s.id === idle.id)
+ok(woken.status === "busy", "idle session went busy after continue")
+ok(woken.tokPerMin > 0, `woken session burning tokens (${woken.tokPerMin}/min)`)
+
+console.log("\ndetail view")
+const d = await get(`/api/sessions/${busy.id}`)
+ok(d.toolLog.length > 0, `tool log populated (${d.toolLog.length} entries, first: ${d.toolLog[0]?.name})`)
+ok(d.transcript.length > 0, `transcript rendered (${d.transcript.length} messages)`)
+ok(typeof d.totals.output === "number" && d.totals.output > 0, `output tokens accumulated (${d.totals.output})`)
+
+console.log("\nabort")
+await fetch(`${url}/api/sessions/${busy.id}/abort`, { method: "POST" })
+await sleep(1800)
+state = await get("/api/state")
+ok(state.sessions.find((s) => s.id === busy.id).status === "idle", "aborted session reports idle")
+
+console.log("\nstatic + stream")
+const html = await fetch(url + "/")
+ok(html.status === 200 && (await html.text()).includes("botfarm"), "dashboard html served")
+const es = await fetch(url + "/api/stream", { headers: { accept: "text/event-stream" } })
+const first = await es.body[Symbol.asyncIterator]().next()
+ok(Buffer.from(first.value).toString().startsWith("data: "), "SSE stream pushes state frames")
+
+console.log("\nmetrics persistence")
+await sup.store.save()
+ok((await import("node:fs")).existsSync(sup.store.statePath), "metrics snapshot written")
+
+await sup.stop()
+mock.kill()
+console.log(process.exitCode ? "\nSOME CHECKS FAILED" : "\nall checks passed")
+process.exit(process.exitCode ?? 0)

package/test/transport.mjs

@@ -0,0 +1,131 @@
+// The transport: a real websocket handshake, pushes without polling, and a
+// count of how often botfarm actually talks to opencode when nothing happens.
+import { spawn } from "node:child_process"
+import { createHash, randomBytes } from "node:crypto"
+import { connect as netConnect } from "node:net"
+import { Supervisor } from "../src/supervisor.mjs"
+import { startServer } from "../src/server.mjs"
+
+const mock = spawn(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)))
+
+await sleep(600)
+const sup = new Supervisor({
+  url: "http://127.0.0.1:4096",
+  statePath: "/tmp/botfarm-ws-" + Date.now() + ".json",
+  registryPath: "/tmp/botfarm-wsreg-" + Date.now() + ".json",
+  mcpBase: "http://127.0.0.1:4801",
+})
+
+// Count every request botfarm makes to opencode, so "does it poll" is a number.
+let calls = []
+const realFetch = globalThis.fetch
+globalThis.fetch = (url, opts) => {
+  const u = String(url)
+  if (u.includes("127.0.0.1:4096")) calls.push(u.replace("http://127.0.0.1:4096", ""))
+  return realFetch(url, opts)
+}
+
+await sup.start()
+startServer({ supervisor: sup, port: 4801 })
+await sup.adopt(sup.unmanaged.map((x) => x.id))
+await sleep(1200)
+
+console.log("websocket handshake")
+const key = randomBytes(16).toString("base64")
+const socket = netConnect(4801, "127.0.0.1")
+const frames = []
+let buf = Buffer.alloc(0)
+let handshake = ""
+await new Promise((resolve) => {
+  socket.on("connect", () => {
+    socket.write(
+      `GET /api/socket HTTP/1.1\r\nHost: 127.0.0.1:4801\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n` +
+        `Sec-WebSocket-Key: ${key}\r\nSec-WebSocket-Version: 13\r\n\r\n`,
+    )
+  })
+  socket.on("data", (chunk) => {
+    if (!handshake) {
+      const split = chunk.indexOf("\r\n\r\n")
+      handshake = chunk.subarray(0, split).toString()
+      chunk = chunk.subarray(split + 4)
+      resolve()
+    }
+    buf = Buffer.concat([buf, chunk])
+    while (true) {
+      const f = readFrame(buf)
+      if (!f) break
+      buf = buf.subarray(f.size)
+      if (f.opcode === 0x1) frames.push(JSON.parse(f.payload.toString()))
+      if (f.opcode === 0x9) socket.write(maskedFrame(Buffer.alloc(0), 0xa)) // answer pings
+    }
+  })
+})
+ok(/101 Switching Protocols/.test(handshake), "server answers with 101")
+const expected = createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64")
+ok(handshake.includes(expected), "and the correct Sec-WebSocket-Accept")
+
+await sleep(400)
+ok(frames.length >= 1, "a snapshot arrives on connect without asking")
+ok(Array.isArray(frames[0].sessions) && frames[0].totals, "and it is the same state the dashboard renders")
+
+console.log("\npush, not poll")
+const before = frames.length
+await sup.send(sup.store.list()[0].id, "hello from the test")
+await sleep(700)
+ok(frames.length > before, `a change pushes a new frame (${frames.length - before})`)
+
+socket.write(maskedFrame(Buffer.from("resync"), 0x1))
+await sleep(400)
+ok(frames.length > before + 1, "and the client can ask for a resync over the same socket")
+
+console.log("\nthe client speaks first: masked frames are decoded")
+ok(frames.at(-1).at > 0, "the resynced frame is well-formed")
+
+console.log("\nshape negotiation does not cache the message")
+const target = sup.store.list()[0]
+await sup.send(target.id, "first message")
+await sup.send(target.id, "second message")
+await sleep(400)
+const sent = (await sup.client.messages(target.id, { limit: 10 }))
+  .flatMap((m) => (m.parts ?? []).map((p) => p.text ?? ""))
+ok(sent.includes("second message"), "the second message carries its own text")
+ok(sent.filter((t) => t === "first message").length === 1, "and the first is not resent")
+
+console.log("\ntraffic to opencode while nothing is happening")
+// stop the mock's busy session so the board is genuinely quiet
+for (const s of sup.store.list()) await sup.abort(s.id).catch(() => {})
+await sleep(2500)
+calls = []
+await sleep(6000)
+const perSecond = calls.length / 6
+console.log(`  ${calls.length} requests in 6s (${perSecond.toFixed(1)}/s):`, [...new Set(calls.map((c) => c.split("?")[0]))].join(", "))
+ok(perSecond < 1.5, `a quiet board is nearly silent (${perSecond.toFixed(1)} requests/second)`)
+ok(!calls.some((c) => c.includes("/message")), "and no message polling at all while idle")
+
+socket.destroy()
+await sup.stop()
+mock.kill()
+console.log(failed ? `\n${failed} CHECKS FAILED` : "\nall checks passed")
+process.exit(failed ? 1 : 0)
+
+// --- a minimal client-side codec, so the test does not trust the server's ---
+function maskedFrame(payload, opcode) {
+  const mask = randomBytes(4)
+  const masked = Buffer.from(payload)
+  for (let i = 0; i < masked.length; i++) masked[i] ^= mask[i % 4]
+  const header = Buffer.from([0x80 | opcode, 0x80 | masked.length])
+  return Buffer.concat([header, mask, masked])
+}
+function readFrame(b) {
+  if (b.length < 2) return null
+  const opcode = b[0] & 0x0f
+  let len = b[1] & 0x7f
+  let off = 2
+  if (len === 126) { if (b.length < 4) return null; len = b.readUInt16BE(2); off = 4 }
+  else if (len === 127) { if (b.length < 10) return null; len = Number(b.readBigUInt64BE(2)); off = 10 }
+  if (b.length < off + len) return null
+  return { opcode, payload: b.subarray(off, off + len), size: off + len }
+}