benchworks 0.3.0 → 0.4.2

package/bin/benchworks.mjs

@@ -5,7 +5,9 @@
  * 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";
@@ -15,9 +17,10 @@ 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.3.0";
+const VERSION = "0.4.2";
 const API = (process.env.BENCHWORKS_URL ?? "https://benchworks.dev").replace(/\/+$/, "");
 const HOME = homedir();
 // the runner's own folder: its key and the folder conversations start in (BENCHWORKS_HOME moves it, for a second pairing on one Mac)
@@ -241,6 +244,8 @@ async function connect(code) {
     } else {
       if (away) say("Back in touch with Benchworks.");
       away = false;
+      // a newer runner is out: once no conversation is running here, it takes over in this window
+      if (newer(answer.body.latest, VERSION) && ![...sessions.values()].some((s) => s.busy)) return update(answer.body.latest);
       if (answer.body.ask === "folder") {
         say("Benchworks asked for a folder. The picker is open.");
         const path = await pickFolder();
@@ -384,12 +389,24 @@ function cleanEnv() {
   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", "--append-system-prompt", rules(known));
+  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)));
   return args;
 }
@@ -515,7 +532,10 @@ function handle(job) {
       if (!s.busy) s.startedAt = Date.now();
       s.busy = true;
       say(dim(`  → ${job.text.split("\n")[0].slice(0, 70)}`));
-      if (!write(s, { type: "user", message: { role: "user", content: [{ type: "text", text: job.text }] } })) emit({ session: spec.id, type: "refused", error: "Claude Code on this Mac stopped taking messages. Send it again." }, true);
+      // 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": {
@@ -564,6 +584,8 @@ async function jobs() {
       continue;
     }
     if (r.status === 401) return;
+    // the runner that took over asks for jobs now; one handed out here unsaid comes to it again
+    if (updating) return;
     for (const job of r.body.jobs ?? []) {
       acks.push(job.id);
       if (seen.has(job.id)) continue;
@@ -579,6 +601,37 @@ setInterval(() => {
   for (const s of sessions.values()) if (!s.busy && Date.now() - s.lastAt > IDLE_MS) end(s, "idle");
 }, 60_000).unref();
 
+/** Whether version a (x.y.z) is newer than b. */
+function newer(a, b) {
+  if (typeof a !== "string" || !/^\d+\.\d+\.\d+$/.test(a)) return false;
+  const x = a.split(".").map(Number);
+  const y = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] > y[i];
+  return false;
+}
+
+let updating = false;
+
+/**
+ * Moves to a newer runner in this same window: the conversations' Claude Code processes end (the next message resumes
+ * each), the new version runs as this one's child with the same key and folder, and this one waits for it and leaves with
+ * it. Ctrl-C reaches both, and the child is the one that answers it.
+ */
+function update(version) {
+  if (updating) return;
+  updating = true;
+  say(`Benchworks runner ${version} is out. Updating; your conversations carry on with your next message.`);
+  for (const s of sessions.values()) end(s, "idle");
+  process.removeAllListeners("SIGINT");
+  process.on("SIGINT", () => {});
+  const child = spawn("npx", ["-y", `benchworks@${version}`, "connect"], { stdio: "inherit", env: { ...process.env, BENCHWORKS_HOME: OWN } });
+  child.on("exit", (code) => process.exit(code ?? 0));
+  child.on("error", (e) => {
+    say(warn(`Could not start ${version} (${e.message}). Run ${again} to update.`));
+    process.exit(1);
+  });
+}
+
 function quit(code = 0) {
   for (const s of sessions.values()) s.proc.kill();
   process.exit(code);
@@ -597,15 +650,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.3.0",
+  "version": "0.4.2",
   "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": {