benchworks 0.0.0-stage → 0.1.1

package/bin/benchworks.mjs

@@ -0,0 +1,244 @@
+#!/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. 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.
+ */
+import { execFile } from "node:child_process";
+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 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);
+
+/* ---------------------------------------------------------------- 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 };
+}
+
+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);
+  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();
+      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.`));
+      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.");
+    } 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));
+  }
+}
+
+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}`);
+  process.exit(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,6 +1,20 @@
 {
   "name": "benchworks",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "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/benchworks.mjs"
+  },
+  "files": [
+    "bin"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin"
+  ],
+  "homepage": "https://benchworks.dev",
+  "license": "UNLICENSED"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.