benchworks 0.1.1 → 0.2.0

package/bin/benchworks.mjs

@@ -2,16 +2,21 @@
 /*
  * Benchworks' runner. `benchworks connect --code XXXX-XXXX` pairs this Mac with your Benchworks account, and keeps it
  * connected while this Terminal window is open. It checks what the Assistant needs (Claude Code, its login, git), finds
- * the git repositories in the usual folders, and reports both to benchworks.dev every few seconds. It sends folder names
- * and versions, never the contents of a file. Run it again without a code and it reconnects as the same Mac.
+ * the git repositories in the usual folders, and reports both to benchworks.dev every few seconds. When you ask the
+ * Assistant something on benchworks.dev, it runs your own Claude Code here, under Benchworks' rules (not your personal
+ * settings or MCP servers), and sends back what Claude says and does; anything that would change a file or run a
+ * command waits for your Allow on the page. Run it again without a code and it reconnects as the same Mac.
  */
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { createInterface } from "node:readline";
 import { chmod, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir, hostname, platform } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
 
-const VERSION = "0.1.1";
+const VERSION = "0.2.0";
 const API = (process.env.BENCHWORKS_URL ?? "https://benchworks.dev").replace(/\/+$/, "");
 const HOME = homedir();
 const STATE = join(HOME, ".benchworks", "runner.json");
@@ -34,6 +39,7 @@ async function out(cmd, args, cwd) {
 }
 
 const tilde = (p) => (p.startsWith(HOME) ? `~${p.slice(HOME.length)}` : p);
+const untilde = (p) => (p.startsWith("~/") ? join(HOME, p.slice(2)) : p);
 
 /* ---------------------------------------------------------------- what the Assistant needs */
 
@@ -112,6 +118,34 @@ async function api(path, body, key) {
   return { status: res.status, body: answer };
 }
 
+/**
+ * The long poll, on a connection of its own: through fetch's shared pool, a request held open for 25 seconds made the
+ * reports and the events wait behind it.
+ */
+function get(path, key) {
+  const url = new URL(`${API}${path}`);
+  const send = url.protocol === "http:" ? httpRequest : httpsRequest;
+  return new Promise((resolve, reject) => {
+    const req = send(url, { headers: { "user-agent": `benchworks-runner/${VERSION}`, authorization: `Bearer ${key}` }, agent: false, timeout: 40_000 }, (res) => {
+      let raw = "";
+      res.setEncoding("utf8");
+      res.on("data", (d) => (raw += d));
+      res.on("end", () => {
+        let body = {};
+        try {
+          body = JSON.parse(raw);
+        } catch {
+          /* not JSON: an error page on the way */
+        }
+        resolve({ status: res.statusCode ?? 0, body });
+      });
+    });
+    req.on("timeout", () => req.destroy(new Error("timeout")));
+    req.on("error", reject);
+    req.end();
+  });
+}
+
 const WHY = {
   no_code: "That code does not work. Make a new one on benchworks.dev and run the command again.",
   used: "That code was used already. Make a new one on benchworks.dev and run the command again.",
@@ -175,6 +209,9 @@ async function connect(code) {
     say(`Reconnecting ${state.machine} as ${state.email}.`);
   }
   printChecks(c, null);
+  key = state.key;
+  known = found;
+  void jobs();
   again = state.again ?? again;
   say(dim(`Keep this window open while you work. Ctrl-C disconnects; to come back, run: ${again}`));
 
@@ -186,16 +223,18 @@ async function connect(code) {
     printChecks(c, before);
     if (Date.now() - foundAt > REPOS_EVERY_MS) {
       found = await repos();
+      known = found;
       foundAt = Date.now();
     }
     const body = { report: report(), ...(picked !== undefined ? { picked } : {}) };
     picked = undefined;
-    const answer = await api("/api/runner/report", body, state.key).catch(() => null);
-    if (!answer || answer.status >= 500) {
-      if (!away) say(warn(`Cannot reach ${API}. Trying again.`));
+    const answer = await api("/api/runner/report", body, state.key).catch((e) => ({ status: 0, body: {}, why: e.cause?.code ?? e.name ?? "error" }));
+    if (answer.status === 0 || answer.status >= 500) {
+      if (!away) say(warn(`Cannot reach ${API} (${answer.why ?? answer.status}). Trying again.`));
       away = true;
     } else if (answer.status === 401) {
-      return fail("Benchworks no longer knows this Mac. Make a new code on benchworks.dev and run the command with it.");
+      fail("Benchworks no longer knows this Mac. Make a new code on benchworks.dev and run the command with it.");
+      return quit(1);
     } else {
       if (away) say("Back in touch with Benchworks.");
       away = false;
@@ -211,6 +250,201 @@ async function connect(code) {
   }
 }
 
+/* ---------------------------------------------------------------- conversations */
+
+const SPACE = join(HOME, ".benchworks", "space");
+const IDLE_MS = 15 * 60_000;
+let key = null;
+let known = [];
+
+/** Benchworks' rules for a conversation: where it starts, the person's repositories, and how to ask before changing. */
+function rules(found) {
+  return [
+    "You are the Benchworks Assistant. You run on the person's own Mac, through their own Claude Code, started from benchworks.dev.",
+    `You start in Benchworks' own folder, ${SPACE}. The person's git repositories on this Mac, newest work first:`,
+    ...found.map((r) => `- ${r.name}: ${untilde(r.path)}${r.branch ? ` (on ${r.branch})` : ""}`),
+    "When they name one, work in it by its full path. Reading them needs no permission; changing a file or running a command asks the person first, on the page.",
+    "Answer plainly and briefly: the person reads you in a browser.",
+  ].join("\n");
+}
+
+/** One line for what a tool does, as the page and the permission card show it. */
+function summarize(name, input = {}) {
+  const path = (p) => (typeof p === "string" ? tilde(p) : "");
+  switch (name) {
+    case "Bash":
+      return String(input.command ?? "").slice(0, 300);
+    case "Read":
+    case "Edit":
+    case "Write":
+    case "NotebookEdit":
+      return path(input.file_path ?? input.notebook_path);
+    case "Grep":
+      return `${input.pattern ?? ""}${input.path ? ` in ${path(input.path)}` : ""}`;
+    case "Glob":
+      return String(input.pattern ?? "");
+    case "WebFetch":
+      return String(input.url ?? "");
+    case "WebSearch":
+      return String(input.query ?? "");
+    default:
+      return JSON.stringify(input).slice(0, 200);
+  }
+}
+
+const sessions = new Map();
+const outbox = [];
+const acks = [];
+let flushing = null;
+let flushTimer = null;
+
+/** Events go to Benchworks in small batches: pieces of text every 150 ms, anything else at once. */
+function emit(event, now = false) {
+  outbox.push(event);
+  if (now) void flush();
+  else if (!flushTimer) flushTimer = setTimeout(() => void flush(), 150);
+}
+
+async function flush() {
+  if (flushTimer) clearTimeout(flushTimer);
+  flushTimer = null;
+  if (flushing) return flushing.then(() => flush());
+  if (!outbox.length && !acks.length) return;
+  const events = outbox.splice(0);
+  const done = acks.splice(0);
+  flushing = api("/api/runner/events", { acks: done, events }, key)
+    .then((r) => r.status < 500, () => false)
+    .then((sent) => {
+      flushing = null;
+      if (!sent) {
+        outbox.unshift(...events);
+        acks.unshift(...done);
+        setTimeout(() => void flush(), 2000);
+      }
+    });
+  return flushing;
+}
+
+function write(s, message) {
+  if (s.proc.stdin.writable) s.proc.stdin.write(`${JSON.stringify(message)}\n`);
+}
+
+/** Claude Code for one conversation, kept open between its turns; a runner that restarted resumes it. */
+function open(job) {
+  const args = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose", "--include-partial-messages"];
+  args.push("--permission-prompt-tool", "stdio", "--setting-sources", "project", "--strict-mcp-config", "--append-system-prompt", rules(known));
+  if (job.session.claudeSessionId) args.push("--resume", job.session.claudeSessionId);
+  if (known.length) args.push("--add-dir", ...known.map((r) => untilde(r.path)));
+  const proc = spawn("claude", args, { cwd: SPACE, stdio: ["pipe", "pipe", "pipe"], env: process.env });
+  const s = { id: job.session.id, proc, busy: false, turns: [], inputs: new Map(), lastAt: Date.now(), stopped: false, err: "", startedAt: 0 };
+  createInterface({ input: proc.stdout }).on("line", (line) => heard(s, line));
+  proc.stderr.on("data", (d) => (s.err = (s.err + d).slice(-2000)));
+  proc.on("error", (e) => {
+    sessions.delete(s.id);
+    emit({ session: s.id, type: "failed", message: `Claude Code could not start: ${e.message}` }, true);
+  });
+  proc.on("exit", (code) => {
+    sessions.delete(s.id);
+    if (s.busy) emit({ session: s.id, type: "failed", message: s.err.trim().split("\n").slice(-3).join(" ") || `Claude Code stopped (exit ${code}).` }, true);
+  });
+  sessions.set(s.id, s);
+  return s;
+}
+
+function ask(s, text) {
+  s.busy = true;
+  s.stopped = false;
+  s.startedAt = Date.now();
+  say(dim(`  → ${text.split("\n")[0].slice(0, 70)}`));
+  write(s, { type: "user", message: { role: "user", content: text } });
+}
+
+/** One line of Claude's stream-json, turned into what the page shows. */
+function heard(s, line) {
+  let m;
+  try {
+    m = JSON.parse(line);
+  } catch {
+    return;
+  }
+  s.lastAt = Date.now();
+  if (m.type === "system" && m.subtype === "init" && m.session_id) {
+    emit({ session: s.id, type: "started", claudeSessionId: m.session_id }, true);
+  } else if (m.type === "stream_event") {
+    const e = m.event;
+    if (e?.type === "content_block_delta" && e.delta?.type === "text_delta") emit({ session: s.id, type: "text", text: e.delta.text });
+  } else if (m.type === "assistant") {
+    const parts = m.message?.content ?? [];
+    for (const p of parts) if (p.type === "tool_use") emit({ session: s.id, type: "tool", id: p.id, name: p.name, summary: summarize(p.name, p.input) }, true);
+    const text = parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+    if (text.trim()) emit({ session: s.id, type: "assistant", text }, true);
+  } else if (m.type === "user") {
+    for (const p of m.message?.content ?? []) if (p.type === "tool_result") emit({ session: s.id, type: "tool_result", id: p.tool_use_id, ok: !p.is_error });
+  } else if (m.type === "control_request" && m.request?.subtype === "can_use_tool") {
+    s.inputs.set(m.request_id, m.request.input);
+    emit({ session: s.id, type: "permission", requestId: m.request_id, tool: m.request.tool_name, summary: summarize(m.request.tool_name, m.request.input) }, true);
+    say(dim(`  ? ${m.request.tool_name} waits for your answer on benchworks.dev`));
+  } else if (m.type === "result") {
+    s.busy = false;
+    emit({ session: s.id, type: "done", error: m.is_error === true && !s.stopped, stopped: s.stopped, ms: m.duration_ms ?? Date.now() - s.startedAt }, true);
+    say(dim(`  ${s.stopped ? "stopped" : "answered"} in ${((Date.now() - s.startedAt) / 1000).toFixed(1)} s`));
+    const next = s.turns.shift();
+    if (next) ask(s, next);
+  }
+}
+
+/** A job from Benchworks: a message to answer, a decision on a permission, or Stop. */
+function handle(job) {
+  let s = sessions.get(job.session.id);
+  if (job.kind === "turn") {
+    s ??= open(job);
+    if (s.busy) s.turns.push(job.text);
+    else ask(s, job.text);
+  } else if (job.kind === "permission") {
+    if (!s) return emit({ session: job.session.id, type: "done", error: true, ms: 0 }, true);
+    const input = s.inputs.get(job.requestId);
+    s.inputs.delete(job.requestId);
+    const response = job.behavior === "allow" ? { behavior: "allow", updatedInput: input ?? {} } : { behavior: "deny", message: "The person said no on benchworks.dev." };
+    write(s, { type: "control_response", response: { subtype: "success", request_id: job.requestId, response } });
+  } else if (job.kind === "stop") {
+    if (!s || !s.busy) return emit({ session: job.session.id, type: "done", stopped: true, ms: 0 }, true);
+    s.stopped = true;
+    s.turns = [];
+    write(s, { type: "control_request", request_id: `stop-${Date.now()}`, request: { subtype: "interrupt" } });
+  }
+}
+
+/** The long poll: Benchworks hands over jobs the moment the page sends them. Each is said to be had, and run once. */
+async function jobs() {
+  await mkdir(SPACE, { recursive: true });
+  const seen = new Set();
+  for (;;) {
+    const r = await get("/api/runner/jobs?wait=25", key).catch(() => null);
+    if (!r || r.status >= 500) {
+      await new Promise((done) => setTimeout(done, 3000));
+      continue;
+    }
+    if (r.status === 401) return;
+    for (const job of r.body.jobs ?? []) {
+      acks.push(job.id);
+      if (seen.has(job.id)) continue;
+      seen.add(job.id);
+      handle(job);
+    }
+    if (acks.length) void flush();
+  }
+}
+
+// a conversation nobody spoke to for a while lets its Claude Code go; the next message resumes it
+setInterval(() => {
+  for (const s of sessions.values()) if (!s.busy && Date.now() - s.lastAt > IDLE_MS) s.proc.kill();
+}, 60_000).unref();
+
+function quit(code = 0) {
+  for (const s of sessions.values()) s.proc.kill();
+  process.exit(code);
+}
+
 function fail(line) {
   say(warn(line));
   process.exitCode = 1;
@@ -226,7 +460,7 @@ let again = "npx benchworks connect";
 
 process.on("SIGINT", () => {
   say(`\nDisconnected. To come back, run: ${again}`);
-  process.exit(0);
+  quit(0);
 });
 
 const [command, ...rest] = process.argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "benchworks",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Connects your Mac to Benchworks, so the Assistant at benchworks.dev runs your own Claude Code with your logins and your files.",
   "type": "module",
   "bin": {