@ra3orblade/swarm 0.4.0

package/dist/swarm.js

@@ -0,0 +1,830 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/cli/src/bin.ts
+import { resolve as resolve3 } from "path";
+
+// packages/client/src/daemon.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// packages/client/src/bins.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var SRC = {
+  swarm: "cli",
+  swarmd: "daemon",
+  "swarm-hook": "hook",
+  "swarm-mcp": "mcp"
+};
+function resolveBin(name, from = import.meta.url) {
+  const here = dirname(fileURLToPath(from));
+  const candidates = [
+    resolve(here, `../../${SRC[name]}/src/bin.ts`),
+    resolve(here, `${name}.js`)
+  ];
+  for (const c of candidates)
+    if (existsSync(c))
+      return ["bun", c];
+  return [name];
+}
+function binCommand(name, from) {
+  return resolveBin(name, from).map((p) => /[\s"']/.test(p) ? JSON.stringify(p) : p).join(" ");
+}
+
+// packages/client/src/daemon.ts
+function swarmHome() {
+  return process.env.SWARM_HOME ?? join(homedir(), ".swarm");
+}
+var DEFAULT_PORT = Number(process.env.SWARM_PORT ?? 7777);
+var infoFile = () => join(swarmHome(), "daemon.json");
+function readDaemonInfo() {
+  const file = infoFile();
+  if (!existsSync2(file))
+    return null;
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function daemonCommand() {
+  return resolveBin("swarmd");
+}
+function resolveBaseUrl(explicit) {
+  const raw = explicit ?? process.env.SWARM_URL ?? readDaemonInfo()?.url ?? `http://127.0.0.1:${DEFAULT_PORT}`;
+  return raw.replace(/\/$/, "");
+}
+async function pingHealth(baseUrl, timeoutMs = 800) {
+  try {
+    const r = await fetch(`${baseUrl}/v1/health`, { signal: AbortSignal.timeout(timeoutMs) });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+async function ensureDaemon(opts = {}) {
+  const baseUrl = resolveBaseUrl(opts.baseUrl);
+  if (await pingHealth(baseUrl))
+    return baseUrl;
+  const info = readDaemonInfo();
+  if (info && alive(info.pid) && await pingHealth(info.url))
+    return info.url;
+  const [cmd, ...args] = daemonCommand();
+  if (!cmd)
+    throw new Error("could not resolve the daemon command");
+  if (!opts.quiet)
+    process.stderr.write(`starting swarmd\u2026
+`);
+  const proc = Bun.spawn([cmd, ...args], {
+    stdout: "ignore",
+    stderr: "ignore",
+    stdin: "ignore",
+    env: { ...process.env }
+  });
+  proc.unref();
+  for (let i = 0;i < 50; i++) {
+    const target = resolveBaseUrl(opts.baseUrl);
+    if (await pingHealth(target, 300))
+      return target;
+    await Bun.sleep(100);
+  }
+  throw new Error("swarmd did not become healthy within 5s");
+}
+
+// packages/client/src/index.ts
+class SwarmClient {
+  baseUrl;
+  f;
+  constructor(opts = {}) {
+    this.baseUrl = resolveBaseUrl(opts.baseUrl);
+    this.f = opts.fetch ?? fetch;
+  }
+  async health() {
+    const r = await this.f(`${this.baseUrl}/v1/health`);
+    if (!r.ok)
+      throw new Error(`swarmd: ${r.status}`);
+    return await r.json();
+  }
+  async emit(event) {
+    const r = await this.f(`${this.baseUrl}/v1/events`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(event)
+    });
+    if (!r.ok)
+      throw new Error(`swarmd: ${r.status}`);
+  }
+}
+
+// packages/cli/src/install.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+// packages/core/src/adapters/claude-code/hooks.ts
+var HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "SubagentStart",
+  "SubagentStop",
+  "Stop",
+  "SessionEnd",
+  "Notification",
+  "PreCompact"
+];
+// packages/core/src/rules.ts
+var LIVE_WINDOW_MS = 10 * 60000;
+var WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+// packages/cli/src/install.ts
+var MARK = "swarm-hook";
+var isOurs = (h) => h.command.includes(MARK) || h.command.includes("/packages/hook/src/bin.ts");
+var settingsPath = () => process.env.CLAUDE_SETTINGS ?? join2(homedir2(), ".claude", "settings.json");
+var hookCommand = (event) => `${binCommand("swarm-hook")} ${event}`;
+var shimPath = () => resolveBin("swarm-hook").at(-1);
+function mcpServerConfig() {
+  const [command, ...args] = resolveBin("swarm-mcp");
+  return { command, args };
+}
+function load() {
+  const p = settingsPath();
+  return existsSync3(p) ? JSON.parse(readFileSync2(p, "utf8")) : {};
+}
+function save(s) {
+  writeFileSync2(settingsPath(), `${JSON.stringify(s, null, 2)}
+`);
+}
+function install() {
+  const s = load();
+  const hooks2 = s.hooks ?? {};
+  const added = [];
+  for (const ev of HOOK_EVENTS) {
+    const list = hooks2[ev] ?? [];
+    const clean = list.map((g) => ({ ...g, hooks: g.hooks.filter((h) => !isOurs(h)) })).filter((g) => g.hooks.length);
+    clean.push({
+      hooks: [{ type: "command", command: hookCommand(ev), timeout: 5 }]
+    });
+    hooks2[ev] = clean;
+    added.push(ev);
+  }
+  s.hooks = hooks2;
+  const mcp = s.mcpServers ?? {};
+  mcp.swarm = { type: "stdio", ...mcpServerConfig() };
+  s.mcpServers = mcp;
+  save(s);
+  return added;
+}
+function uninstall() {
+  const s = load();
+  const hooks2 = s.hooks ?? {};
+  let removed = 0;
+  for (const ev of Object.keys(hooks2)) {
+    const before = hooks2[ev] ?? [];
+    const after = before.map((g) => ({
+      ...g,
+      hooks: g.hooks.filter((h) => {
+        if (isOurs(h)) {
+          removed++;
+          return false;
+        }
+        return true;
+      })
+    })).filter((g) => g.hooks.length);
+    if (after.length)
+      hooks2[ev] = after;
+    else
+      delete hooks2[ev];
+  }
+  if (Object.keys(hooks2).length)
+    s.hooks = hooks2;
+  else
+    delete s.hooks;
+  const mcp = s.mcpServers ?? {};
+  if (mcp.swarm) {
+    delete mcp.swarm;
+    removed++;
+  }
+  if (Object.keys(mcp).length)
+    s.mcpServers = mcp;
+  else
+    delete s.mcpServers;
+  save(s);
+  return removed;
+}
+function status() {
+  const s = load();
+  const hooks2 = s.hooks ?? {};
+  const installed = Object.values(hooks2).some((l) => l.some((g) => g.hooks.some(isOurs)));
+  const mcp = Boolean(s.mcpServers?.swarm);
+  return { installed, mcp, path: settingsPath(), shim: shimPath() };
+}
+
+// packages/cli/src/procs.ts
+import { mkdirSync as mkdirSync2, openSync } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+async function call(path, init) {
+  const r = await fetch(`${new SwarmClient().baseUrl}${path}`, init);
+  return await r.json();
+}
+var post = (path, body) => call(path, {
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify(body)
+});
+async function projectId() {
+  const p = await post("/v1/projects", { path: resolve2(".") });
+  return p.id;
+}
+var slug = (s) => s.replace(/[^a-zA-Z0-9_.-]+/g, "-").slice(0, 60) || "proc";
+async function start(opts) {
+  if (!opts.cmd.length)
+    throw new Error("nothing to run \u2014 put the command after `--`");
+  const pid = await projectId();
+  let port = null;
+  if (opts.kind === "serve") {
+    if (opts.port)
+      port = opts.port;
+    else {
+      const a = await post("/v1/ports/allocate", { from: opts.fromPort });
+      if (!a.ok || !a.port)
+        throw new Error(a.error ?? "no free port");
+      port = a.port;
+    }
+  }
+  const logDir = join3(swarmHome(), "logs", slug(pid));
+  mkdirSync2(logDir, { recursive: true });
+  const log = join3(logDir, `${slug(opts.name)}.log`);
+  const fd = openSync(log, "a");
+  const cmdline = opts.cmd.join(" ");
+  const child = Bun.spawn(["sh", "-c", cmdline], {
+    cwd: resolve2("."),
+    env: { ...process.env, ...port ? { PORT: String(port) } : {}, SWARM_PROC: opts.name },
+    stdin: "ignore",
+    stdout: fd,
+    stderr: fd,
+    detached: true
+  });
+  child.unref();
+  const r = await post("/v1/processes", {
+    pid: child.pid,
+    projectId: pid,
+    sessionId: process.env.CLAUDE_SESSION_ID ?? null,
+    kind: opts.kind,
+    name: opts.name,
+    port,
+    cwd: resolve2("."),
+    cmd: cmdline,
+    owner: opts.owner,
+    log
+  });
+  if (!r.ok || !r.process) {
+    try {
+      process.kill(child.pid, "SIGTERM");
+    } catch {}
+    throw new Error(r.error ?? "registration failed");
+  }
+  return r.process;
+}
+async function list(kind) {
+  const pid = await projectId();
+  const rows = await call(`/v1/processes?project=${pid}`);
+  return kind ? rows.filter((r) => r.kind === kind) : rows;
+}
+async function stop(target, kind) {
+  const rows = await list(kind);
+  let victims;
+  if (!target)
+    victims = kind === "serve" && rows.length === 1 ? rows : [];
+  else if (/^\d+$/.test(target))
+    victims = rows.filter((r) => r.pid === Number(target));
+  else
+    victims = rows.filter((r) => r.name === target);
+  if (!victims.length) {
+    if (!target && rows.length > 1)
+      throw new Error(`several ${kind}s running \u2014 name one: ${rows.map((r) => r.name).join(", ")}`);
+    throw new Error(target ? `no registered ${kind} "${target}" in this project` : `no ${kind} running here`);
+  }
+  const pid = await projectId();
+  for (const v of victims) {
+    const r = await call(`/v1/processes/${v.pid}?project=${pid}`, { method: "DELETE" });
+    if (!r.ok)
+      throw new Error(r.error ?? `could not stop ${v.pid}`);
+  }
+  return victims;
+}
+function fmt(r) {
+  const where = r.port != null ? `:${r.port}`.padEnd(7) : "".padEnd(7);
+  return `${r.kind.padEnd(6)} ${r.name.padEnd(14)} pid ${String(r.pid).padEnd(7)} ${where} ${r.cmd.slice(0, 50)}`;
+}
+
+// packages/cli/src/bin.ts
+var [cmd = "help", ...rest] = process.argv.slice(2);
+var json = rest.includes("--json");
+var arg = () => rest.find((a) => !a.startsWith("--"));
+var help = `swarm \u2014 control plane for AI-agent development
+
+  setup              start the daemon, install hooks, open the dashboard (do this first)
+  start | stop | restart   manage the background daemon
+  status [-p]        live sessions (whole machine, or one project)
+  doctor             check everything and print the fix for each gap
+
+  add <path> [--name n]   register (pin) a project
+  ls                 list projects
+  ui                 open the dashboard
+  tail [--project p] [--session id]   follow the live event stream
+
+  claim <task> [--owner n]   claim a task in a fresh isolated git worktree (fail-closed)
+  renew <task>            extend the lease;  release <task> [--force]   release + remove worktree
+  claims                  list claims;  reap   release abandoned claims (keeps ones holding work)
+  tasks [--ready] [--json] the repo's task source (.swarm.toml [tasks] source); --ready = claimable now
+  res ls | acquire <name> [--owner n] [--pid n] [--port n] | release <name> [--force]
+                          named singletons (ports, processes); fail-closed
+  serve start [--name web] [--from-port 3400 | --port n] -- <cmd>
+                          start a dev server: port allocated, PORT set, pid tracked, port protected
+  serve ls | stop [name]  list / stop servers this project started (by pid, never by pattern)
+  proc start [--name n] -- <cmd> | ls | stop <name|pid>   same, for workers without a port
+  stats [-p] [--json]     all-time totals, streak, records (the dashboard's Stats view)
+
+  install | uninstall     add/remove Swarm hooks in ~/.claude/settings.json
+
+Env: SWARM_URL, SWARM_PORT (default 7777), SWARM_HOME (~/.swarm)`;
+async function api(path, init) {
+  const base = new SwarmClient().baseUrl;
+  const r = await fetch(`${base}${path}`, init);
+  if (!r.ok)
+    throw new Error(`${path}: ${r.status} ${await r.text()}`);
+  return r.status === 204 ? null : r.json();
+}
+async function daemonRunning() {
+  try {
+    await new SwarmClient().health();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stopDaemon() {
+  const info = readDaemonInfo();
+  if (!info)
+    return false;
+  try {
+    process.kill(info.pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+try {
+  switch (cmd) {
+    case "setup": {
+      const base = await ensureDaemon();
+      const evs = install();
+      console.log(`\u2713 daemon running at ${base}`);
+      console.log(`\u2713 installed hooks for ${evs.length} events + MCP server (${status().path})`);
+      console.log("\u2713 any Claude session you start now will appear in Swarm");
+      Bun.spawn(["open", base]).unref?.();
+      console.log(`
+Open the dashboard: ${base}`);
+      break;
+    }
+    case "start": {
+      if (await daemonRunning()) {
+        console.log(`already running at ${new SwarmClient().baseUrl}`);
+        break;
+      }
+      const base = await ensureDaemon();
+      console.log(`started at ${base}`);
+      break;
+    }
+    case "stop":
+      console.log(await stopDaemon() ? "stopped" : "not running");
+      break;
+    case "restart":
+      await stopDaemon();
+      await Bun.sleep(300);
+      console.log(`restarted at ${await ensureDaemon()}`);
+      break;
+    case "install": {
+      const evs = install();
+      console.log(`installed hooks for ${evs.length} events in ${status().path}`);
+      console.log("restart any running claude session for it to report in.");
+      break;
+    }
+    case "uninstall":
+      console.log(`removed ${uninstall()} hook entries`);
+      break;
+    case "doctor": {
+      const st = status();
+      const bun = Bun.which("bun");
+      const claude = Bun.which("claude");
+      const info = readDaemonInfo();
+      const running = await daemonRunning();
+      const line = (ok, label, fix) => console.log(`${ok ? "\u2713" : "\u2717"} ${label}${ok ? "" : `  \u2192 ${fix}`}`);
+      line(Boolean(bun), `bun ${bun ? `(${bun})` : ""}`, "install bun: https://bun.sh");
+      line(Boolean(claude), "claude CLI on PATH", "install Claude Code: https://claude.com/claude-code");
+      line(running, `daemon ${info ? `(pid ${info.pid}, ${info.url})` : ""}`, "run: swarm start");
+      line(st.installed, "hooks installed", "run: swarm install");
+      line(st.mcp, "MCP server registered", "run: swarm install");
+      const forge2 = (bin, auth) => {
+        const path = Bun.which(bin);
+        if (!path)
+          return console.log(`\xB7 ${bin} not found \u2014 PRs view skips ${bin === "gh" ? "GitHub" : "GitLab"} repos`);
+        const ok = Bun.spawnSync([path, ...auth], { stdout: "ignore", stderr: "ignore" }).exitCode === 0;
+        line(ok, `${bin} authenticated (${path})`, `run: ${bin} auth login`);
+      };
+      forge2("gh", ["auth", "status", "--active", "-h", "github.com"]);
+      forge2("glab", ["auth", "status"]);
+      if (process.env.GITLAB_TOKEN)
+        console.log("\xB7 glab uses GITLAB_TOKEN from this shell \u2014 a daemon started by the desktop app won't see it; run `glab auth login` to store it instead");
+      if (!running)
+        process.exitCode = 1;
+      console.log(`
+settings: ${st.path}
+daemon cmd: ${daemonCommand().join(" ")}
+url: ${resolveBaseUrl()}`);
+      break;
+    }
+    case "add": {
+      await ensureDaemon({ quiet: true });
+      const p = resolve3(arg() ?? ".");
+      const nameIdx = rest.indexOf("--name");
+      const name = nameIdx >= 0 ? rest[nameIdx + 1] : undefined;
+      const proj = await api("/v1/projects", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ path: p, name })
+      });
+      console.log(json ? JSON.stringify(proj) : `added ${proj.name} (${proj.id}) \u2192 ${proj.root}`);
+      break;
+    }
+    case "claim": {
+      await ensureDaemon({ quiet: true });
+      const task = arg();
+      if (!task)
+        throw new Error("usage: swarm claim <task> [--owner name]");
+      const ownerIdx = rest.indexOf("--owner");
+      const owner = ownerIdx >= 0 ? rest[ownerIdx + 1] : process.env.USER ?? "me";
+      const proj = await api("/v1/projects", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ path: resolve3(".") })
+      });
+      const r = await fetch(`${new SwarmClient().baseUrl}/v1/claims`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ projectId: proj.id, task, owner })
+      }).then((x) => x.json());
+      if (json)
+        console.log(JSON.stringify(r));
+      else if (r.ok)
+        console.log(`claimed ${task} \u2192 ${r.worktree}
+  cd ${r.worktree}`);
+      else {
+        console.error(`REFUSED: ${r.error}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "renew":
+    case "release": {
+      await ensureDaemon({ quiet: true });
+      const task = arg();
+      if (!task)
+        throw new Error(`usage: swarm ${cmd} <task>${cmd === "release" ? " [--force]" : ""}`);
+      const proj = await api("/v1/projects", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ path: resolve3(".") })
+      });
+      const r = await fetch(`${new SwarmClient().baseUrl}/v1/claims/${cmd}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ projectId: proj.id, task, force: rest.includes("--force") })
+      }).then((x) => x.json());
+      if (json)
+        console.log(JSON.stringify(r));
+      else if (r.ok)
+        console.log(cmd === "renew" ? `renewed ${task} until ${r.expiresAt}` : `released ${task}`);
+      else {
+        console.error(`REFUSED: ${r.error}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "reap": {
+      await ensureDaemon({ quiet: true });
+      const r = await api("/v1/claims/reap", { method: "POST" });
+      if (json)
+        console.log(JSON.stringify(r));
+      else if (r.reaped.length)
+        for (const x of r.reaped)
+          console.log(`${x.action.padEnd(14)} ${x.task}`);
+      else
+        console.log("nothing to reap");
+      break;
+    }
+    case "claims": {
+      await ensureDaemon({ quiet: true });
+      const cs = await api("/v1/claims");
+      if (json)
+        console.log(JSON.stringify(cs));
+      else if (!cs.length)
+        console.log("no claims");
+      else
+        for (const c of cs)
+          console.log(`${c.state.padEnd(9)} ${c.task.padEnd(16)} ${(c.owner || "").padEnd(12)} ${c.worktree}`);
+      break;
+    }
+    case "tasks": {
+      await ensureDaemon({ quiet: true });
+      const proj = await api("/v1/projects", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ path: resolve3(".") })
+      });
+      const t = await api(`/v1/tasks?project=${proj.id}`);
+      const ready = rest.includes("--ready");
+      const rows = ready ? t.tasks.filter((x) => x.ready) : t.tasks;
+      if (json)
+        console.log(JSON.stringify(rows));
+      else if (!t.source)
+        console.log('no task source \u2014 add `[tasks] source = "path/to/plan.md"` to .swarm.toml');
+      else if (!rows.length)
+        console.log(ready ? "nothing ready to claim" : `no tasks in ${t.source}`);
+      else
+        for (const x of rows) {
+          const st = x.claimedBy ? `held:${x.claimedBy}` : x.ready ? "ready" : x.status;
+          console.log(`${st.padEnd(14)} ${x.id.padEnd(8)} ${x.title.slice(0, 60).padEnd(60)} ${x.depends.join(",")}`);
+        }
+      break;
+    }
+    case "serve":
+    case "proc": {
+      await ensureDaemon({ quiet: true });
+      const kind = cmd;
+      const dash = rest.indexOf("--");
+      const head = dash >= 0 ? rest.slice(0, dash) : rest;
+      const tail = dash >= 0 ? rest.slice(dash + 1) : [];
+      const flag = (n) => {
+        const i = head.indexOf(n);
+        return i >= 0 ? head[i + 1] : undefined;
+      };
+      const num = (n) => {
+        const v = flag(n);
+        return v != null && Number.isFinite(Number(v)) ? Number(v) : undefined;
+      };
+      const valueFlags = new Set(["--name", "--from-port", "--port", "--owner"]);
+      const positionals = [];
+      for (let i = 0;i < head.length; i++) {
+        const a = head[i];
+        if (valueFlags.has(a))
+          i++;
+        else if (!a.startsWith("--"))
+          positionals.push(a);
+      }
+      const sub = positionals[0] ?? "ls";
+      if (sub === "start") {
+        const name = flag("--name") ?? (kind === "serve" ? "web" : tail[0]?.split("/").pop() ?? "proc");
+        const p = await start({
+          kind,
+          name,
+          cmd: tail,
+          fromPort: num("--from-port"),
+          port: num("--port"),
+          owner: flag("--owner") ?? process.env.USER ?? "me"
+        });
+        if (json)
+          console.log(JSON.stringify(p));
+        else
+          console.log(`started ${p.name}${p.port ? ` on :${p.port}` : ""} (pid ${p.pid})
+  log: ${p.log}
+  stop: swarm ${kind} stop ${p.name}`);
+        break;
+      }
+      if (sub === "ls") {
+        const rows = await list(kind);
+        if (json)
+          console.log(JSON.stringify(rows));
+        else if (!rows.length)
+          console.log(`no ${kind === "serve" ? "servers" : "processes"} running here`);
+        else
+          for (const r of rows)
+            console.log(fmt(r));
+        break;
+      }
+      if (sub === "stop") {
+        const stopped = await stop(positionals[1], kind);
+        if (json)
+          console.log(JSON.stringify(stopped));
+        else
+          for (const r of stopped)
+            console.log(`stopped ${r.name} (pid ${r.pid})`);
+        break;
+      }
+      throw new Error(`usage: swarm ${kind} start|ls|stop`);
+    }
+    case "ls": {
+      await ensureDaemon({ quiet: true });
+      const ps = await api("/v1/projects");
+      if (json)
+        console.log(JSON.stringify(ps));
+      else
+        for (const p of ps)
+          console.log(`${p.discovered ? "\u25CB" : "\u25CF"} ${p.name.padEnd(20)} ${p.root}`);
+      break;
+    }
+    case "status": {
+      await ensureDaemon({ quiet: true });
+      const s = await api("/v1/state");
+      if (json) {
+        console.log(JSON.stringify(s));
+        break;
+      }
+      const name = (id) => s.projects.find((p) => p.id === id)?.name ?? "?";
+      const live = s.sessions.filter((x) => x.state === "active" || x.state === "waiting");
+      for (const x of live)
+        console.log(`${x.state === "active" ? "\u25CF" : "\u25D0"} ${name(x.projectId).padEnd(16)} ${x.id.slice(0, 8)}  ${x.last.slice(0, 60).padEnd(60)} ${x.costUsd != null ? `$${x.costUsd.toFixed(2)}` : ""}`);
+      if (!live.length)
+        console.log("no live sessions");
+      for (const r of s.resources ?? []) {
+        const via = r.port != null ? `:${r.port}` : r.pid != null ? `pid ${r.pid}` : "";
+        console.log(`  res ${r.name.padEnd(16)} ${r.owner.padEnd(12)} ${r.projectId ? name(r.projectId) : "global"} ${via}`);
+      }
+      break;
+    }
+    case "stats": {
+      await ensureDaemon({ quiet: true });
+      let q = "";
+      if (rest.includes("-p")) {
+        const proj = await api("/v1/projects", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ path: resolve3(".") })
+        });
+        q = `?project=${encodeURIComponent(proj.id)}`;
+      }
+      const st = await api(`/v1/stats${q}`);
+      if (json) {
+        console.log(JSON.stringify(st));
+        break;
+      }
+      const T = st.totals;
+      const usd = (n) => n == null ? "\u2014" : `$${n.toFixed(2)}`;
+      console.log(`since ${T.firstTs?.slice(0, 10) ?? "\u2014"}: ${T.turns} turns, ${T.sessions} sessions, ${T.toolCalls} tool calls, ${usd(T.cost)}`);
+      console.log(`tokens: in ${T.input} \xB7 out ${T.output} \xB7 cache read ${T.cacheRead} \xB7 cache write ${T.cacheWrite} \xB7 thinking ${T.thinking}`);
+      console.log(`active days (365d): ${st.daily.filter((d) => d.turns).length}`);
+      for (const m of st.byModel.slice(0, 5))
+        console.log(`  ${m.model.padEnd(28)} ${String(m.turns).padStart(6)} turns ${m.output} out`);
+      if (st.records.busiestDay)
+        console.log(`busiest day: ${st.records.busiestDay.day} (${st.records.busiestDay.turns} turns, ${usd(st.records.busiestDay.cost)})`);
+      break;
+    }
+    case "res": {
+      await ensureDaemon({ quiet: true });
+      const valueFlags = new Set(["--owner", "--pid", "--port"]);
+      const positionals = [];
+      for (let i = 0;i < rest.length; i++) {
+        const a = rest[i];
+        if (valueFlags.has(a))
+          i++;
+        else if (!a.startsWith("--"))
+          positionals.push(a);
+      }
+      const sub = positionals[0];
+      const flag = (n) => {
+        const i = rest.indexOf(n);
+        return i >= 0 ? rest[i + 1] : undefined;
+      };
+      const numFlag = (n) => {
+        const v = flag(n);
+        const x = v != null ? Number(v) : undefined;
+        return x != null && Number.isFinite(x) ? x : undefined;
+      };
+      if (sub === "ls" || !sub) {
+        const list2 = await api("/v1/resources");
+        if (json)
+          console.log(JSON.stringify(list2));
+        else if (!list2.length)
+          console.log("no resources held");
+        else
+          for (const r of list2)
+            console.log(`${r.kind.padEnd(8)} ${r.name.padEnd(16)} ${r.owner.padEnd(12)} ${r.port != null ? `:${r.port}` : r.pid != null ? `pid ${r.pid}` : ""}`);
+        break;
+      }
+      if (sub === "acquire") {
+        const name = positionals[1];
+        if (!name)
+          throw new Error("usage: swarm res acquire <name> [--owner n] [--pid n] [--port n]");
+        const proj = await api("/v1/projects", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ path: resolve3(".") })
+        });
+        const r = await fetch(`${new SwarmClient().baseUrl}/v1/resources`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            name,
+            owner: flag("--owner") ?? process.env.USER ?? "me",
+            pid: numFlag("--pid"),
+            port: numFlag("--port"),
+            projectId: proj.id
+          })
+        }).then((x) => x.json());
+        if (json)
+          console.log(JSON.stringify(r));
+        else if (r.ok)
+          console.log(`acquired ${name}`);
+        else {
+          console.error(`REFUSED: ${r.error}`);
+          process.exit(1);
+        }
+        break;
+      }
+      if (sub === "release") {
+        const name = positionals[1];
+        if (!name)
+          throw new Error("usage: swarm res release <name> [--owner n] [--force]");
+        const proj = await api("/v1/projects", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ path: resolve3(".") })
+        });
+        const q = new URLSearchParams({
+          project: proj.id,
+          owner: flag("--owner") ?? process.env.USER ?? "me"
+        });
+        if (rest.includes("--force"))
+          q.set("force", "1");
+        const r = await fetch(`${new SwarmClient().baseUrl}/v1/resources/${encodeURIComponent(name)}?${q}`, { method: "DELETE" }).then((x) => x.json());
+        if (json)
+          console.log(JSON.stringify(r));
+        else if (r.ok)
+          console.log(`released ${name}`);
+        else {
+          console.error(`REFUSED: ${r.error}`);
+          process.exit(1);
+        }
+        break;
+      }
+      throw new Error("usage: swarm res ls | acquire <name> | release <name> [--force]");
+    }
+    case "tail": {
+      await ensureDaemon({ quiet: true });
+      const base = new SwarmClient().baseUrl;
+      const pIdx = rest.indexOf("--session");
+      const wantSession = pIdx >= 0 ? rest[pIdx + 1] : undefined;
+      const res = await fetch(`${base}/v1/events?since=0`);
+      const reader = res.body?.getReader();
+      if (!reader)
+        throw new Error("no stream");
+      const dec = new TextDecoder;
+      let buf = "";
+      for (;; ) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        buf += dec.decode(value, { stream: true });
+        const parts = buf.split(`
+
+`);
+        buf = parts.pop() ?? "";
+        for (const block of parts) {
+          const data = block.split(`
+`).find((l) => l.startsWith("data:"))?.slice(5).trim();
+          if (!data)
+            continue;
+          try {
+            const e = JSON.parse(data);
+            if (wantSession && e.sessionId !== wantSession)
+              continue;
+            console.log(`${e.ts.slice(11, 19)} ${e.type.padEnd(18)} ${e.payload?.summary ?? ""}`);
+          } catch {}
+        }
+      }
+      break;
+    }
+    case "ui": {
+      const base = await ensureDaemon();
+      Bun.spawn(["open", base]).unref?.();
+      console.log(base);
+      break;
+    }
+    default:
+      console.log(help);
+  }
+} catch (e) {
+  console.error(e.message);
+  process.exit(2);
+}