benchworks 0.0.1 → 0.2.0

package/bin/benchworks.mjs

@@ -0,0 +1,478 @@
+#!/usr/bin/env node
+/*
+ * 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. 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, 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.2.0";
+const API = (process.env.BENCHWORKS_URL ?? "https://benchworks.dev").replace(/\/+$/, "");
+const HOME = homedir();
+const STATE = join(HOME, ".benchworks", "runner.json");
+const EVERY_MS = 5_000;
+const REPOS_EVERY_MS = 60_000;
+
+const run = promisify(execFile);
+const say = (line = "") => process.stdout.write(`${line}\n`);
+const dim = (s) => (process.stdout.isTTY ? `\x1b[2m${s}\x1b[0m` : s);
+const ok = (s) => (process.stdout.isTTY ? `\x1b[32m${s}\x1b[0m` : s);
+const warn = (s) => (process.stdout.isTTY ? `\x1b[33m${s}\x1b[0m` : s);
+
+async function out(cmd, args, cwd) {
+  try {
+    const { stdout } = await run(cmd, args, { cwd, timeout: 8_000, env: process.env });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+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 */
+
+async function checks() {
+  const claudeOut = await out("claude", ["--version"]);
+  const claude = claudeOut ? { ok: true, detail: claudeOut.split(/\s+/)[0] ?? claudeOut } : { ok: false, detail: "" };
+  let login = { ok: false, detail: "" };
+  if (claude.ok) {
+    // who Claude Code is signed in as, from its own settings; only the address is read
+    try {
+      const settings = JSON.parse(await readFile(join(HOME, ".claude.json"), "utf8"));
+      const email = settings?.oauthAccount?.emailAddress;
+      if (typeof email === "string" && email) login = { ok: true, detail: email };
+    } catch {
+      /* no settings file: not signed in */
+    }
+    if (!login.ok && process.env.ANTHROPIC_API_KEY) login = { ok: true, detail: "with an API key" };
+  }
+  const gitOut = await out("git", ["--version"]);
+  const git = gitOut ? { ok: true, detail: gitOut.replace(/^git version\s*/, "").split(/\s+/)[0] } : { ok: false, detail: "" };
+  return { claude, login, git };
+}
+
+/* ---------------------------------------------------------------- the repositories on this Mac */
+
+const SKIP = new Set(["Library", "Applications", "Movies", "Music", "Pictures", "Public", "Downloads", "node_modules"]);
+
+async function dirs(path) {
+  try {
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP.has(e.name)).slice(0, 200).map((e) => join(path, e.name));
+  } catch {
+    return [];
+  }
+}
+
+const isRepo = (path) => stat(join(path, ".git")).then(() => true, () => false);
+
+/** Git repositories in the home folder and one level down, and in ~/Documents/GitHub; newest work first. */
+async function repos() {
+  const found = new Set();
+  for (const top of await dirs(HOME)) {
+    if (await isRepo(top)) found.add(top);
+    else for (const inner of await dirs(top)) if (await isRepo(inner)) found.add(inner);
+  }
+  for (const inner of await dirs(join(HOME, "Documents", "GitHub"))) if (await isRepo(inner)) found.add(inner);
+  const list = await Promise.all(
+    [...found].map(async (path) => ({
+      name: path.split("/").pop(),
+      path: tilde(path),
+      branch: (await out("git", ["rev-parse", "--abbrev-ref", "HEAD"], path)) ?? "",
+      at: (await out("git", ["log", "-1", "--format=%cI"], path)) || null,
+    })),
+  );
+  return list.sort((a, b) => (b.at ?? "").localeCompare(a.at ?? "")).slice(0, 20);
+}
+
+/* ---------------------------------------------------------------- talking to Benchworks */
+
+async function machine() {
+  if (platform() === "darwin") {
+    const name = await out("scutil", ["--get", "ComputerName"]);
+    if (name) return name;
+  }
+  return hostname();
+}
+
+async function api(path, body, key) {
+  const res = await fetch(`${API}${path}`, {
+    method: "POST",
+    headers: { "content-type": "application/json", "user-agent": `benchworks-runner/${VERSION}`, ...(key ? { authorization: `Bearer ${key}` } : {}) },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(15_000),
+  });
+  const answer = await res.json().catch(() => ({}));
+  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.",
+  expired: "That code ran out. Make a new one on benchworks.dev and run the command again.",
+  too_many_tries: "Too many codes that did not work. Wait ten minutes, then try a new one.",
+};
+
+async function readState() {
+  try {
+    return JSON.parse(await readFile(STATE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function saveState(state) {
+  await mkdir(join(HOME, ".benchworks"), { recursive: true, mode: 0o700 });
+  await writeFile(STATE, JSON.stringify(state, null, 2), { mode: 0o600 });
+  await chmod(STATE, 0o600);
+}
+
+/** The folder picker the page asked for: the Mac's own, through AppleScript. Null when it was cancelled. */
+async function pickFolder() {
+  const path = await out("osascript", ["-e", 'POSIX path of (choose folder with prompt "Pick the folder Benchworks should work in")']);
+  return path ? tilde(path.replace(/\/$/, "")) : null;
+}
+
+function printChecks(c, before) {
+  const lines = [
+    ["claude", c.claude.ok ? `Claude Code ${c.claude.detail}` : "Claude Code is not on this Mac. Install it: npm install -g @anthropic-ai/claude-code"],
+    ["login", c.login.ok ? `Signed in to Claude Code as ${c.login.detail}` : c.claude.ok ? "Claude Code is not signed in. Run claude and sign in with /login" : null],
+    ["git", c.git.ok ? `git ${c.git.detail}` : "git is not on this Mac. Install Apple's command line tools: xcode-select --install"],
+  ];
+  for (const [id, line] of lines) {
+    if (!line) continue;
+    if (before && before[id]?.ok === c[id].ok && before[id]?.detail === c[id].detail) continue;
+    say(`  ${c[id].ok ? ok("✓") : warn("✗")} ${line}`);
+  }
+}
+
+async function connect(code) {
+  say(`Benchworks runner ${VERSION}`);
+  if (platform() !== "darwin") say(warn("Benchworks runs on macOS for now; this may not work here."));
+  let found = await repos();
+  let foundAt = Date.now();
+  let c = await checks();
+  const report = () => ({ version: VERSION, platform: platform(), checks: c, repos: found });
+
+  let state = await readState();
+  if (code) {
+    const name = await machine();
+    const paired = await api("/api/runner/pair", { code, machine: name, report: report() }).catch(() => null);
+    if (!paired) return fail(`Cannot reach ${API}. Check the connection and run the command again.`);
+    if (paired.status !== 201) return fail(WHY[paired.body.error] ?? `Benchworks said no (${paired.body.error ?? paired.status}).`);
+    state = { url: API, runnerId: paired.body.runnerId, key: paired.body.token, email: paired.body.email, machine: name, again: paired.body.again };
+    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.");
+  } else {
+    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}`));
+
+  let away = false;
+  let picked;
+  for (;;) {
+    const before = c;
+    c = await checks();
+    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((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) {
+      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;
+      if (answer.body.ask === "folder") {
+        say("Benchworks asked for a folder. The picker is open.");
+        const path = await pickFolder();
+        picked = path ?? "";
+        say(path ? `  Working in ${path}` : "  No folder picked.");
+        continue;
+      }
+    }
+    await new Promise((r) => setTimeout(r, EVERY_MS));
+  }
+}
+
+/* ---------------------------------------------------------------- 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;
+}
+
+function usage() {
+  say("Usage: npx benchworks connect --code XXXX-XXXX");
+  say("       npx benchworks connect          (again, on a Mac that is connected already)");
+}
+
+/** 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);
+});
+
+const [command, ...rest] = process.argv.slice(2);
+const at = rest.indexOf("--code");
+const code = at >= 0 ? rest[at + 1] : undefined;
+if (command === "connect") {
+  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") {
+  say(VERSION);
+} else {
+  usage();
+  if (command && command !== "--help" && command !== "-h") process.exitCode = 1;
+}
+

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "benchworks",
-  "version": "0.0.1",
-  "description": "Benchworks connects your Mac to Benchworks so its agent can work on your code. Not released yet.",
+  "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": {
-    "benchworks": "bin.js"
+    "benchworks": "bin/benchworks.mjs"
   },
   "files": [
-    "bin.js",
-    "README.md"
+    "bin"
   ],
   "engines": {
     "node": ">=18"
   },
+  "os": [
+    "darwin"
+  ],
+  "homepage": "https://benchworks.dev",
   "license": "UNLICENSED"
 }

package/README.md

@@ -1,7 +0,0 @@
-# Benchworks
-
-Benchworks is a design workbench: review a pull request's running preview with your team, and let your own coding agent
-act on the feedback.
-
-This package will carry the runner that connects your Mac to Benchworks (`npx benchworks connect`). It is not released
-yet.

package/bin.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-console.log("The Benchworks runner is not released yet.");