benchworks 0.2.0 → 0.4.0

package/bin/benchworks.mjs

@@ -5,21 +5,27 @@
  * 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.
+ * command waits for your Allow on the page (unless you picked Full access). Claude Code also gets Benchworks' own tools
+ * (`benchworks mcp`, this file again) to keep your projects on benchworks.dev, and sees the pictures you attach.
+ * Run it again without a code and it reconnects as the same Mac.
  */
 import { execFile, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 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 { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 
-const VERSION = "0.2.0";
+const VERSION = "0.4.0";
 const API = (process.env.BENCHWORKS_URL ?? "https://benchworks.dev").replace(/\/+$/, "");
 const HOME = homedir();
-const STATE = join(HOME, ".benchworks", "runner.json");
+// the runner's own folder: its key and the folder conversations start in (BENCHWORKS_HOME moves it, for a second pairing on one Mac)
+const OWN = process.env.BENCHWORKS_HOME ?? join(HOME, ".benchworks");
+const STATE = join(OWN, "runner.json");
 const EVERY_MS = 5_000;
 const REPOS_EVERY_MS = 60_000;
 
@@ -162,7 +168,7 @@ async function readState() {
 }
 
 async function saveState(state) {
-  await mkdir(join(HOME, ".benchworks"), { recursive: true, mode: 0o700 });
+  await mkdir(OWN, { recursive: true, mode: 0o700 });
   await writeFile(STATE, JSON.stringify(state, null, 2), { mode: 0o600 });
   await chmod(STATE, 0o600);
 }
@@ -204,7 +210,7 @@ async function connect(code) {
     await saveState(state);
     say(`Connected ${name} to Benchworks as ${paired.body.email}.`);
   } else if (!state?.key) {
-    return fail("This Mac is not connected yet. Copy the command with its code from benchworks.dev and run it here.");
+    return fail("This Mac is not connected yet. On benchworks.dev, open Settings › Your Macs, choose Connect a Mac, and run the command it gives you here.");
   } else {
     say(`Reconnecting ${state.machine} as ${state.email}.`);
   }
@@ -252,8 +258,19 @@ async function connect(code) {
 
 /* ---------------------------------------------------------------- conversations */
 
-const SPACE = join(HOME, ".benchworks", "space");
+/*
+ * A conversation runs as one Claude Code process per conversation, kept open between its turns, the way the local
+ * workbench's daemon runs it (daemon/src/agent/driver.ts and runner.ts): stream-json in and out, permission asks over
+ * stdio. What Claude says goes to Benchworks in the daemon's own shapes (messages of blocks, text deltas, permission
+ * requests, one result per turn), so benchworks.dev shows it with the workbench's own page.
+ */
+
+const SPACE = join(OWN, "space");
 const IDLE_MS = 15 * 60_000;
+const KILL_GRACE_MS = 5_000;
+const RESULT_TEXT_MAX = 50_000;
+const INPUT_STRING_MAX = 20_000;
+const STATUS_SUBTYPES = ["status", "thinking_tokens", "post_turn_summary", "api_retry"];
 let key = null;
 let known = [];
 
@@ -268,30 +285,6 @@ function rules(found) {
   ].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 = [];
@@ -325,92 +318,256 @@ async function flush() {
   return flushing;
 }
 
-function write(s, message) {
-  if (s.proc.stdin.writable) s.proc.stdin.write(`${JSON.stringify(message)}\n`);
+const record = (v) => (typeof v === "object" && v !== null && !Array.isArray(v) ? v : null);
+const str = (v) => (typeof v === "string" ? v : null);
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+const list = (v) => (Array.isArray(v) ? v : []);
+const clipText = (s, max) => (s.length > max ? `${s.slice(0, max)}\n… (${s.length - max} more characters on the Mac)` : s);
+
+/** A tool's input as the page shows it: long strings (a whole file for Write) are cut so a message stays small. */
+function clipInput(v) {
+  if (typeof v === "string") return clipText(v, INPUT_STRING_MAX);
+  if (Array.isArray(v)) return v.map(clipInput);
+  const o = record(v);
+  return o ? Object.fromEntries(Object.entries(o).map(([k, x]) => [k, clipInput(x)])) : v;
+}
+
+/** A tool result's text; pictures stay on the Mac for now, and Claude's note naming one stays as it is. */
+function resultText(v) {
+  if (typeof v === "string") return v;
+  return list(v)
+    .map((item) => (record(item)?.type === "text" ? (str(item.text) ?? "") : ""))
+    .filter(Boolean)
+    .join("\n");
+}
+
+/** Claude Code's content blocks as the workbench's AgentBlocks (driver.ts parseBlocks). */
+function parseBlocks(content) {
+  if (typeof content === "string") return content ? [{ type: "text", text: content }] : [];
+  const out = [];
+  for (const block of list(content)) {
+    const b = record(block);
+    if (!b) continue;
+    if (b.type === "text") {
+      if (str(b.text) !== null) out.push({ type: "text", text: b.text });
+    } else if (b.type === "thinking") {
+      out.push({ type: "thinking", text: str(b.thinking) ?? "" });
+    } else if (b.type === "redacted_thinking") {
+      out.push({ type: "thinking", text: "" });
+    } else if (b.type === "tool_use") {
+      if (str(b.id) !== null && str(b.name) !== null) out.push({ type: "tool_use", id: b.id, name: b.name, input: clipInput(b.input) });
+    } else if (b.type === "tool_result") {
+      if (str(b.tool_use_id) !== null) out.push({ type: "tool_result", toolUseId: b.tool_use_id, content: clipText(resultText(b.content), RESULT_TEXT_MAX), isError: b.is_error === true });
+    }
+  }
+  return out;
 }
 
-/** 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);
+/** An AskUserQuestion result also carries the answers by question; they go on the result (driver.ts withToolAnswers). */
+function withToolAnswers(blocks, toolUseResult) {
+  const given = record(record(toolUseResult)?.answers);
+  if (!given) return blocks;
+  const answers = Object.fromEntries(Object.entries(given).filter(([, a]) => typeof a === "string"));
+  const results = blocks.filter((b) => b.type === "tool_result");
+  if (results.length !== 1 || Object.keys(answers).length === 0) return blocks;
+  return blocks.map((b) => (b.type === "tool_result" ? { ...b, answers } : b));
+}
+
+function describeSystem(m, subtype) {
+  const detail = str(m.status) ?? str(m.status_detail) ?? str(m.message) ?? str(m.error);
+  if (subtype === "api_retry") return `api retry${num(m.attempt) !== null ? ` ${m.attempt}` : ""}${detail ? `: ${detail}` : ""}`;
+  if (subtype === "thinking_tokens") return num(m.tokens) !== null ? `thinking (${m.tokens} tokens)` : "thinking";
+  return detail ?? subtype;
+}
+
+/** Claude Code's environment without the variables a Claude Code session sets, so one started from inside Claude Code still runs. */
+function cleanEnv() {
+  const env = { ...process.env };
+  for (const k of Object.keys(env)) if (k.startsWith("CLAUDECODE") || k.startsWith("CLAUDE_CODE_")) delete env[k];
+  return env;
+}
+
+/** Benchworks' own tools for one conversation: this file again, as an MCP server on stdio (`benchworks mcp`). */
+function benchTools(spec) {
+  return JSON.stringify({
+    mcpServers: {
+      benchworks: { type: "stdio", command: process.execPath, args: [fileURLToPath(import.meta.url), "mcp"], env: { BENCHWORKS_SESSION: spec.id, BENCHWORKS_HOME: OWN } },
+    },
+  });
+}
+
+function argv(spec) {
+  const args = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--permission-prompt-tool", "stdio"];
+  args.push("--model", spec.model, "--effort", spec.effort);
+  // Full access can be picked mid-conversation; Claude Code allows the switch only to a process started able to
+  args.push("--allow-dangerously-skip-permissions");
+  if (spec.permissionMode && spec.permissionMode !== "default") args.push("--permission-mode", spec.permissionMode);
+  if (spec.cliSessionId) args.push("--resume", spec.cliSessionId);
+  args.push("--setting-sources", "project", "--strict-mcp-config", "--mcp-config", benchTools(spec), "--allowedTools", "mcp__benchworks");
+  args.push("--append-system-prompt", rules(known));
   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 };
+  return args;
+}
+
+function write(s, message) {
+  if (!s.proc.stdin.writable) return false;
+  s.proc.stdin.write(`${JSON.stringify(message)}\n`);
+  return true;
+}
+
+/** Claude Code for one conversation; a runner that restarted, or a process that idled out, resumes it. */
+function open(spec) {
+  const proc = spawn("claude", argv(spec), { cwd: SPACE, stdio: ["pipe", "pipe", "pipe"], env: cleanEnv() });
+  const s = { id: spec.id, spec, proc, busy: false, inputs: new Map(), lastAt: Date.now(), ending: null, interrupted: false, respawn: false, stderr: [], startedAt: 0, costBase: 0 };
   createInterface({ input: proc.stdout }).on("line", (line) => heard(s, line));
-  proc.stderr.on("data", (d) => (s.err = (s.err + d).slice(-2000)));
+  createInterface({ input: proc.stderr }).on("line", (line) => {
+    if (line.trim()) s.stderr = [...s.stderr, line].slice(-20);
+  });
   proc.on("error", (e) => {
     sessions.delete(s.id);
-    emit({ session: s.id, type: "failed", message: `Claude Code could not start: ${e.message}` }, true);
+    s.ending ??= "crashed";
+    emit({ session: s.id, type: "refused", error: `Claude Code could not start on this Mac: ${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);
+  proc.on("exit", (code, signal) => {
+    if (sessions.get(s.id) === s) sessions.delete(s.id);
+    if (s.ending === "crashed") return;
+    const reason = s.ending ?? (code === 0 && !s.busy ? "stopped" : "crashed");
+    emit({ session: s.id, type: "exit", reason, code, signal, stderr: s.stderr.slice(-5) }, 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 } });
+/** Ends a conversation's process: on Stop, or quietly when it idled or must start again with another effort. */
+function end(s, reason) {
+  if (s.ending) return;
+  s.ending = reason;
+  try {
+    s.proc.stdin.end();
+  } catch {
+    /* stdin closed already */
+  }
+  s.proc.kill("SIGTERM");
+  setTimeout(() => s.proc.exitCode === null && s.proc.kill("SIGKILL"), KILL_GRACE_MS).unref();
+}
+
+function control(s, request) {
+  return write(s, { type: "control_request", request_id: randomUUID(), request });
 }
 
-/** One line of Claude's stream-json, turned into what the page shows. */
+/** One line of Claude's stream-json, sent on as the daemon's driver reads it. */
 function heard(s, line) {
   let m;
   try {
     m = JSON.parse(line);
   } catch {
+    if (line.trim()) s.stderr = [...s.stderr, line].slice(-20);
     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);
+  const type = m?.type;
+  if (type === "system") {
+    if (m.subtype === "init" && str(m.session_id)) emit({ session: s.id, type: "init", cliSessionId: m.session_id, model: str(m.model), version: str(m.claude_code_version) }, true);
+    else if (STATUS_SUBTYPES.includes(m.subtype)) emit({ session: s.id, type: "status", text: describeSystem(m, m.subtype) });
+  } else if (type === "stream_event") {
+    const e = record(m.event);
+    const delta = record(e?.delta);
+    if (e?.type !== "content_block_delta" || delta?.type !== "text_delta" || !str(delta.text)) return;
+    emit({ session: s.id, type: "delta", messageId: str(m.api_message_id) ?? str(m.uuid) ?? "", index: num(e.index) ?? 0, text: delta.text });
+  } else if (type === "assistant" || type === "user") {
+    const message = record(m.message);
+    if (!message) return;
+    const blocks = withToolAnswers(parseBlocks(message.content), m.tool_use_result);
+    if (!blocks.length) return;
+    emit({ session: s.id, type: "message", message: { uuid: str(m.uuid) ?? randomUUID(), role: type, at: str(m.timestamp), blocks, parentToolUseId: str(m.parent_tool_use_id) } }, true);
+  } else if (type === "control_request") {
+    const request = record(m.request);
+    if (request?.subtype !== "can_use_tool" || !str(m.request_id)) return;
+    s.inputs.set(m.request_id, request.input);
+    const toolName = str(request.tool_name) ?? "tool";
+    emit(
+      {
+        session: s.id,
+        type: "permission",
+        request: { requestId: m.request_id, toolName, displayName: str(request.display_name) ?? toolName, input: clipInput(request.input), description: str(request.description), toolUseId: str(request.tool_use_id) },
+      },
+      true,
+    );
+    say(dim(`  ? ${toolName} waits for your answer on benchworks.dev`));
+  } else if (type === "result") {
+    const total = num(m.total_cost_usd) ?? 0;
+    const costUsd = Math.max(0, total - s.costBase);
+    s.costBase = Math.max(s.costBase, total);
+    const queued = num(m.queued_turn_count) ?? 0;
+    s.busy = queued > 0;
+    s.inputs.clear();
+    emit(
+      {
+        session: s.id,
+        type: "result",
+        result: { subtype: str(m.subtype) ?? "unknown", isError: m.is_error === true, costUsd, durationMs: num(m.duration_ms) ?? 0, turns: num(m.num_turns) ?? 0, text: str(m.result), cliSessionId: str(m.session_id), queued, interrupted: s.interrupted },
+      },
+      true,
+    );
+    say(dim(`  ${s.interrupted ? "stopped" : "answered"} in ${((Date.now() - s.startedAt) / 1000).toFixed(1)} s`));
+    s.interrupted = false;
+    if (!s.busy && s.respawn) end(s, "idle");
   }
 }
 
-/** A job from Benchworks: a message to answer, a decision on a permission, or Stop. */
+/** A job from Benchworks: a message, an answer to an ask, an interrupt, new settings, 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" } });
+  const spec = job.session;
+  let s = sessions.get(spec.id);
+  if (s?.ending) s = undefined;
+  switch (job.kind) {
+    case "send": {
+      s ??= open(spec);
+      if (job.now && s.busy) {
+        s.interrupted = true;
+        control(s, { subtype: "interrupt" });
+      }
+      if (!s.busy) s.startedAt = Date.now();
+      s.busy = true;
+      say(dim(`  → ${job.text.split("\n")[0].slice(0, 70)}`));
+      // pictures the person attached go first, as Claude Code takes them
+      const pictures = (Array.isArray(job.images) ? job.images : []).map((img) => ({ type: "image", source: { type: "base64", media_type: img.mediaType, data: img.data } }));
+      const content = [...pictures, ...(job.text.trim() ? [{ type: "text", text: job.text }] : [])];
+      if (!write(s, { type: "user", message: { role: "user", content } })) emit({ session: spec.id, type: "refused", error: "Claude Code on this Mac stopped taking messages. Send it again." }, true);
+      return;
+    }
+    case "permission": {
+      if (!s || !s.inputs.has(job.requestId)) return emit({ session: spec.id, type: "refused", error: "Claude was not waiting on that any more: its process on this Mac had ended. Send your message again." }, true);
+      const input = s.inputs.get(job.requestId);
+      s.inputs.delete(job.requestId);
+      const answers = record(job.answers);
+      const updatedInput = answers && Object.keys(answers).length ? { ...(record(input) ?? {}), answers } : input;
+      const response = job.behavior === "allow" ? { behavior: "allow", updatedInput } : { behavior: "deny", message: job.message ?? "Denied on benchworks.dev" };
+      write(s, { type: "control_response", response: { subtype: "success", request_id: job.requestId, response } });
+      return;
+    }
+    case "interrupt": {
+      if (!s?.busy) return;
+      s.interrupted = true;
+      control(s, { subtype: "interrupt" });
+      return;
+    }
+    case "set": {
+      if (!s) return;
+      if (job.model) control(s, { subtype: "set_model", model: job.model });
+      if (job.permissionMode) control(s, { subtype: "set_permission_mode", mode: job.permissionMode });
+      // the effort is fixed when Claude Code starts: the next message starts it again, resuming the conversation
+      if (job.effort && job.effort !== s.spec.effort) {
+        s.respawn = true;
+        if (!s.busy) end(s, "idle");
+      }
+      s.spec = { ...s.spec, ...(job.model ? { model: job.model } : {}), ...(job.permissionMode ? { permissionMode: job.permissionMode } : {}) };
+      return;
+    }
+    case "stop": {
+      if (s) end(s, "stopped");
+      return;
+    }
   }
 }
 
@@ -437,7 +594,7 @@ async function jobs() {
 
 // 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();
+  for (const s of sessions.values()) if (!s.busy && Date.now() - s.lastAt > IDLE_MS) end(s, "idle");
 }, 60_000).unref();
 
 function quit(code = 0) {
@@ -458,15 +615,120 @@ function usage() {
 /** How this Mac comes back without a code; Benchworks says which command when it pairs. */
 let again = "npx benchworks connect";
 
-process.on("SIGINT", () => {
-  say(`\nDisconnected. To come back, run: ${again}`);
-  quit(0);
-});
+
+/* ---------------------------------------------------------------- Benchworks' tools for Claude Code (MCP on stdio) */
+
+const TOOLS = [
+  {
+    name: "projects_list",
+    description: "List the projects on the person's Benchworks Projects page (the folders of their current place), with their links.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  },
+  {
+    name: "project_create",
+    description: "Create a project on the person's Benchworks Projects page: one product, client or idea, with optional links to its repository, pull requests and previews.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "The project's name, as the person would say it." },
+        color: { type: "string", description: "A folder tint as #rrggbb (optional)." },
+        links: { type: "array", items: { type: "object", properties: { label: { type: "string" }, url: { type: "string" } }, required: ["url"] } },
+      },
+      required: ["name"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "project_update",
+    description: "Rename a project, change its tint, or replace its links (send the whole list).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        name: { type: "string" },
+        color: { type: ["string", "null"] },
+        links: { type: "array", items: { type: "object", properties: { label: { type: "string" }, url: { type: "string" } }, required: ["url"] } },
+      },
+      required: ["id"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "project_delete",
+    description: "Delete a project from the Projects page. Only when the person asks for it.",
+    inputSchema: { type: "object", properties: { id: { type: "string" } }, required: ["id"], additionalProperties: false },
+  },
+];
+
+/** One call to Benchworks for the tools, as this Mac, for the conversation the server was started for. */
+async function bench(method, path, body) {
+  const state = await readState();
+  if (!state?.key) throw new Error("This Mac is not connected to Benchworks.");
+  const res = await fetch(`${state.url ?? API}/api/runner/bench${path}`, {
+    method,
+    headers: { "content-type": "application/json", authorization: `Bearer ${state.key}`, "x-benchworks-session": process.env.BENCHWORKS_SESSION ?? "" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const answer = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(answer.message ?? `Benchworks answered ${res.status}.`);
+  return answer;
+}
+
+async function callTool(name, args = {}) {
+  switch (name) {
+    case "projects_list":
+      return bench("GET", "/projects");
+    case "project_create":
+      return bench("POST", "/projects", args);
+    case "project_update": {
+      const { id, ...patch } = args;
+      return bench("PATCH", `/projects/${encodeURIComponent(id)}`, patch);
+    }
+    case "project_delete":
+      return bench("DELETE", `/projects/${encodeURIComponent(args.id)}`);
+    default:
+      throw new Error(`No tool named ${name}.`);
+  }
+}
+
+/** The MCP server: JSON-RPC lines on stdin and stdout, the tools above, nothing else. */
+function mcp() {
+  const reply = (id, result) => process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);
+  const fault = (id, code, message) => process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } })}\n`);
+  createInterface({ input: process.stdin }).on("line", async (line) => {
+    let m;
+    try {
+      m = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (m.id === undefined) return;
+    if (m.method === "initialize") return reply(m.id, { protocolVersion: m.params?.protocolVersion ?? "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "benchworks", version: VERSION } });
+    if (m.method === "ping") return reply(m.id, {});
+    if (m.method === "tools/list") return reply(m.id, { tools: TOOLS });
+    if (m.method === "tools/call") {
+      try {
+        const result = await callTool(m.params?.name, m.params?.arguments ?? {});
+        return reply(m.id, { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] });
+      } catch (e) {
+        return reply(m.id, { content: [{ type: "text", text: e.message }], isError: true });
+      }
+    }
+    fault(m.id, -32601, `No method ${m.method}.`);
+  });
+}
 
 const [command, ...rest] = process.argv.slice(2);
 const at = rest.indexOf("--code");
 const code = at >= 0 ? rest[at + 1] : undefined;
-if (command === "connect") {
+if (command === "mcp") {
+  mcp();
+} else if (command === "connect") {
+  // the tools server (`mcp`) speaks only JSON on stdout, so the goodbye belongs to the connected runner alone
+  process.on("SIGINT", () => {
+    say(`\nDisconnected. To come back, run: ${again}`);
+    quit(0);
+  });
   if (rest.includes("--always-on")) say(dim("--always-on comes with the next version; for now, keep this window open."));
   await connect(code?.toUpperCase());
 } else if (command === "--version" || command === "-v") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "benchworks",
-  "version": "0.2.0",
+  "version": "0.4.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": {