tryharness 0.7.18 → 0.7.23

package/lib/runner.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import { agentEnvironment } from "./agentnode.mjs";
 
 const running = new Set();
 const children = new Map();
@@ -21,6 +22,13 @@ export function trackRun(runId, stop) {
   return () => { if (children.get(runId) === entry) children.delete(runId); };
 }
 
+/** A short command the daemon runs itself (an agent listing its models): while it runs, not the person's session either. */
+export function trackHelper(child) {
+  const id = `helper:${child.pid}`;
+  children.set(id, child);
+  child.on("close", () => children.delete(id));
+}
+
 /** The process ids of the runs in progress, so they are not mistaken for the person's own sessions. */
 export function runningPids() {
   return [...children.values()].map((child) => child.pid).filter(Boolean);
@@ -48,12 +56,21 @@ export const restrictedMcpConfig = () => ({ mcpServers: { harness: { command: pr
 const restrictedClaude = (task) => ["--permission-mode", "dontAsk", "--allowedTools", task.readOnly ? "mcp__harness" : "Edit Write mcp__harness",
   "--setting-sources", "user", "--settings", JSON.stringify(RESTRICTED_CLAUDE_SETTINGS), "--strict-mcp-config", "--mcp-config", JSON.stringify(restrictedMcpConfig())];
 
+// The model and effort the relay chose for the run (models.mjs), in each agent's own flags; none leaves its settings as they are.
+const MODEL_FLAGS = {
+  "claude-code": { model: (id) => ["--model", id], effort: (level) => ["--effort", level] },
+  codex: { model: (id) => ["-m", id], effort: (level) => ["-c", `model_reasoning_effort="${level}"`] },
+  pi: { model: (id) => ["--model", id], effort: (level) => ["--thinking", level] },
+  opencode: { model: (id) => ["-m", id], effort: (level) => ["--variant", level] },
+};
+const modelFlags = ({ agent, model, effort }) => [...(model ? MODEL_FLAGS[agent]?.model(model) ?? [] : []), ...(effort ? MODEL_FLAGS[agent]?.effort(effort) ?? [] : [])];
+
 export function agentInvocation(task) {
   if (task.agent === "claude-code") {
     return {
       command: "claude",
       // A review reads and reports: plan mode lets Claude Code read and run read-only tools but never edit.
-      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", ...(task.restricted ? restrictedClaude(task) : task.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
+      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", ...(task.restricted ? restrictedClaude(task) : task.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...modelFlags(task), ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
     };
   }
   // Only Claude Code has a restricted mode; any other agent's restricted run is refused here, whatever let it start.
@@ -61,15 +78,15 @@ export function agentInvocation(task) {
   if (task.agent === "codex") {
     return {
       command: "codex",
-      args: ["exec", ...(task.resumeSession ? ["resume", task.resumeSession] : []), "--json", ...(task.readOnly ? ["-c", 'sandbox_mode="read-only"', "-c", 'approval_policy="never"'] : ["--dangerously-bypass-approvals-and-sandbox"]), "--skip-git-repo-check", "-"],
+      args: ["exec", ...(task.resumeSession ? ["resume", task.resumeSession] : []), "--json", ...modelFlags(task), ...(task.readOnly ? ["-c", 'sandbox_mode="read-only"', "-c", 'approval_policy="never"'] : ["--dangerously-bypass-approvals-and-sandbox"]), "--skip-git-repo-check", "-"],
       stdin: task.brief,
     };
   }
   // Pi has no permission prompts. --approve trusts project-local configuration for
   // this non-interactive run; its complete built-in tool set remains enabled.
-  if (task.agent === "pi") return { command: "pi", args: ["--mode", "json", "--approve", "-p", task.brief] };
+  if (task.agent === "pi") return { command: "pi", args: ["--mode", "json", "--approve", ...modelFlags(task), "-p", task.brief] };
   if (task.agent === "opencode") {
-    return { command: "opencode", args: ["run", "--format", "json", "--auto", ...(task.resumeSession ? ["--session", task.resumeSession] : ["--title", task.title]), "--", task.brief] };
+    return { command: "opencode", args: ["run", "--format", "json", "--auto", ...modelFlags(task), ...(task.resumeSession ? ["--session", task.resumeSession] : ["--title", task.title]), "--", task.brief] };
   }
   throw new Error(`Unsupported agent: ${task.agent}`);
 }
@@ -160,9 +177,13 @@ export function runAgentTask(task, emit, observe = () => {}) {
   }
   let cwd;
   let invocation;
+  let environment;
   try {
     cwd = resolveWorkingDirectory(task.cwd);
     invocation = agentInvocation(task);
+    // A Node agent runs on a Node it accepts, whichever Node Harness itself runs on.
+    environment = agentEnvironment(invocation.command);
+    if (environment.error) throw new Error(environment.error);
   } catch (error) {
     emit("failed", error.message);
     return;
@@ -170,7 +191,9 @@ export function runAgentTask(task, emit, observe = () => {}) {
   emit("accepted");
   let child;
   try {
-    child = spawn(invocation.command, invocation.args, { cwd });
+    child = spawn(invocation.command, invocation.args, { cwd, env: environment.env });
+    // An agent that exits before reading its brief breaks the pipe; its exit says how the run went.
+    child.stdin.on("error", () => {});
     child.stdin.end(invocation.stdin);
   } catch (error) {
     running.delete(slot);
@@ -181,6 +204,7 @@ export function runAgentTask(task, emit, observe = () => {}) {
   children.set(task.runId, child);
 
   let resultText = "";
+  let modelError = "";
   let tail = "";
   let buffer = "";
   let sessionReported = false;
@@ -205,6 +229,12 @@ export function runAgentTask(task, emit, observe = () => {}) {
       if (event.type === "result" && typeof event.result === "string") resultText = event.result;
       if (event.type === "item.completed" && event.item?.type === "agent_message" && typeof event.item.text === "string") resultText = event.item.text;
       if (["text", "message.part.updated"].includes(event.type) && typeof event.part?.text === "string") resultText = event.part.text;
+      // Pi: its last words are its answer; when its model call fails, Pi still exits 0 with the error on the message.
+      if (event.type === "message_end" && event.message?.role === "assistant") {
+        const said = (Array.isArray(event.message.content) ? event.message.content : []).filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+        if (said) resultText = said;
+        modelError = event.message.stopReason === "error" ? String(event.message.errorMessage || "no error message") : "";
+      }
       for (const step of stepsOf(event)) emit("progress", step.text.slice(0, 200), { step });
     }
   });
@@ -216,7 +246,8 @@ export function runAgentTask(task, emit, observe = () => {}) {
   child.on("close", (code) => {
     running.delete(slot);
     children.delete(task.runId);
-    if (code === 0) emit("done", (resultText || "The run finished; check the repository for its changes.").slice(0, 20_000), { usage: usage.result() });
+    if (code === 0 && modelError) emit("failed", `${task.agent} stopped on an error from its model: ${modelError}`.slice(0, 4_000), { usage: usage.result() });
+    else if (code === 0) emit("done", (resultText || "The run finished; check the repository for its changes.").slice(0, 20_000), { usage: usage.result() });
     else emit("failed", (`${task.agent} exited with code ${code}.\n${tail}`).slice(0, 4_000), { usage: usage.result() });
   });
   child.on("error", (error) => {

package/lib/runtime-install.mjs

@@ -12,10 +12,10 @@ function dependencyTarget(root, name) {
   return path.join(root, "node_modules", ...name.split("/"));
 }
 
-// What the runtime keeps of a large package. onnxruntime-web ships browser bundles for every
-// backend (125 MB); the daemon needs its Node entry and the one wasm binary that entry loads.
+// What the runtime keeps of a large package. onnxruntime-node ships native binaries for every OS (about 200 MB); the
+// daemon needs its JavaScript and this machine's own binary.
 const KEEP = {
-  "onnxruntime-web": ["package.json", "types.d.ts", "dist/ort.node.min.mjs", "dist/ort.node.min.js", "dist/ort-wasm-simd-threaded.wasm", "dist/ort-wasm-simd-threaded.mjs"],
+  "onnxruntime-node": ["package.json", "dist", "lib", `bin/napi-v6/${process.platform}/${process.arch}`],
 };
 
 function copyPackage(source, target, name) {
@@ -25,7 +25,7 @@ function copyPackage(source, target, name) {
     const from = path.join(source, file);
     if (!fs.existsSync(from)) continue;
     ensureDir(path.dirname(path.join(target, file)));
-    fs.cpSync(from, path.join(target, file), { force: true });
+    fs.cpSync(from, path.join(target, file), { recursive: true, force: true });
   }
 }
 
@@ -76,7 +76,8 @@ export function installRuntime({ sourceRoot, version }) {
       if (!fs.existsSync(source)) continue;
       fs.cpSync(source, path.join(staging, entry), { recursive: true, force: true });
     }
-    copyDependencyClosure(sourceRoot, staging, ["node-sqlite3-wasm", "ws", "onnxruntime-web", "@huggingface/tokenizers", "@clack/prompts", "@clack/core", "picocolors"]);
+    // Everything the package depends on, so a dependency added there cannot be left out here.
+    copyDependencyClosure(sourceRoot, staging, Object.keys(readJson(path.join(sourceRoot, "package.json"), {}).dependencies || {}));
     fs.writeFileSync(path.join(staging, ".ready"), version + "\n", { mode: 0o600 });
     ensureDir(path.dirname(release));
     fs.rmSync(release, { recursive: true, force: true });

package/lib/screens.mjs

@@ -0,0 +1,96 @@
+import { decodeImage } from "./ocr.mjs";
+
+// Two screenshots of the same screen, before and after an agent's UI change: which parts of the picture changed, and
+// what the text on screen says now that it did not before. The pixels find where; the text read on this computer
+// (ocr.mjs) finds what, down to a lost space ("yet OPEN" becoming "yetOPEN"). Code only, no model judges: the agent
+// that made the change reads the list against what it was asked to do.
+
+const CELL = 16;
+// A cell counts as changed when its pixels differ by more than this on average (0 to 255): re-rendering the same page
+// moves anti-aliasing by a little; the ui-checks eval set it against identical renders.
+const CELL_DIFF = 6;
+const MIN_OVERLAP = 0.3;
+
+const luminance = (data, i) => 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
+const overlap = (a, b) => {
+  const w = Math.max(0, Math.min(a[2], b[2]) - Math.max(a[0], b[0])), h = Math.max(0, Math.min(a[3], b[3]) - Math.max(a[1], b[1]));
+  const area = (box) => Math.max(1, (box[2] - box[0]) * (box[3] - box[1]));
+  return (w * h) / Math.min(area(a), area(b));
+};
+
+/** Changed regions of two same-size images: [{ box: [x0, y0, x1, y1], share }], largest first. */
+export function changedRegions(before, after, { cell = CELL, threshold = CELL_DIFF } = {}) {
+  const cols = Math.ceil(before.width / cell), rows = Math.ceil(before.height / cell);
+  const changed = new Uint8Array(cols * rows);
+  for (let cy = 0; cy < rows; cy += 1) for (let cx = 0; cx < cols; cx += 1) {
+    let sum = 0, count = 0;
+    for (let y = cy * cell; y < Math.min(before.height, (cy + 1) * cell); y += 1) for (let x = cx * cell; x < Math.min(before.width, (cx + 1) * cell); x += 1) {
+      const i = (y * before.width + x) * 4;
+      sum += Math.abs(luminance(before.data, i) - luminance(after.data, i)) + Math.abs(before.data[i] - after.data[i]) / 3 + Math.abs(before.data[i + 2] - after.data[i + 2]) / 3;
+      count += 1;
+    }
+    if (sum / count > threshold) changed[cy * cols + cx] = 1;
+  }
+  // Touching changed cells become one region.
+  const regions = [];
+  const seen = new Uint8Array(cols * rows);
+  for (let start = 0; start < changed.length; start += 1) {
+    if (!changed[start] || seen[start]) continue;
+    const stack = [start];
+    seen[start] = 1;
+    let x0 = Infinity, y0 = Infinity, x1 = -1, y1 = -1, cells = 0;
+    while (stack.length) {
+      const at = stack.pop(), cx = at % cols, cy = (at - cx) / cols;
+      cells += 1; x0 = Math.min(x0, cx); y0 = Math.min(y0, cy); x1 = Math.max(x1, cx); y1 = Math.max(y1, cy);
+      for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1], [1, 1], [-1, -1], [1, -1], [-1, 1]]) {
+        const nx = cx + dx, ny = cy + dy, next = ny * cols + nx;
+        if (nx >= 0 && ny >= 0 && nx < cols && ny < rows && changed[next] && !seen[next]) { seen[next] = 1; stack.push(next); }
+      }
+    }
+    regions.push({ box: [x0 * cell, y0 * cell, Math.min(before.width, (x1 + 1) * cell), Math.min(before.height, (y1 + 1) * cell)], share: Math.round((cells / (cols * rows)) * 10_000) / 10_000 });
+  }
+  return regions.sort((a, b) => b.share - a.share);
+}
+
+/** Lines of text read before and after, paired by where they sit: { changed: [{ before, after, box }], moved, removed, added }. */
+export function textChanges(beforeLines, afterLines) {
+  const used = new Set();
+  const changed = [], removed = [];
+  for (const line of beforeLines) {
+    const same = afterLines.findIndex((other, i) => !used.has(i) && other.text === line.text && overlap(line.box, other.box) >= MIN_OVERLAP);
+    if (same >= 0) { used.add(same); continue; }
+    let best = -1, bestOverlap = MIN_OVERLAP;
+    afterLines.forEach((other, i) => { const o = overlap(line.box, other.box); if (!used.has(i) && o >= bestOverlap) { best = i; bestOverlap = o; } });
+    if (best >= 0) { used.add(best); changed.push({ before: line.text, after: afterLines[best].text, box: afterLines[best].box }); }
+    else removed.push({ text: line.text, box: line.box });
+  }
+  const added = afterLines.filter((_, i) => !used.has(i)).map((line) => ({ text: line.text, box: line.box }));
+  // The same words gone from one place and new in another moved.
+  const moved = [];
+  for (const line of [...removed]) {
+    const to = added.findIndex((other) => other.text === line.text);
+    if (to < 0) continue;
+    moved.push({ text: line.text, from: line.box, to: added[to].box });
+    removed.splice(removed.indexOf(line), 1);
+    added.splice(to, 1);
+  }
+  return { changed, moved, removed, added };
+}
+
+/** Compares two screenshots (PNG or JPEG bytes): { size, regions, text, summary }. */
+export async function compareScreens(beforeBytes, afterBytes, { ocr, lane = "interactive" }) {
+  const before = decodeImage(beforeBytes), after = decodeImage(afterBytes);
+  if (!before || !after) throw new Error("both screenshots must be PNG or JPEG");
+  const sameSize = before.width === after.width && before.height === after.height;
+  const regions = sameSize ? changedRegions(before, after) : [];
+  const [readBefore, readAfter] = [await ocr.read(before, { lane }), await ocr.read(after, { lane })];
+  const text = textChanges(readBefore.lines, readAfter.lines);
+  const parts = [];
+  if (!sameSize) parts.push(`the screenshots differ in size (${before.width}x${before.height} and ${after.width}x${after.height}), so only their text was compared`);
+  else parts.push(regions.length ? `${regions.length} region${regions.length === 1 ? "" : "s"} of the picture changed` : "no part of the picture changed");
+  for (const change of text.changed) parts.push(`"${change.before}" now reads "${change.after}"`);
+  for (const line of text.moved) parts.push(`"${line.text}" moved`);
+  if (text.removed.length) parts.push(`gone: ${text.removed.map((line) => `"${line.text}"`).join(", ")}`);
+  if (text.added.length) parts.push(`new: ${text.added.map((line) => `"${line.text}"`).join(", ")}`);
+  return { size: { before: [before.width, before.height], after: [after.width, after.height] }, regions: regions.slice(0, 20), text, summary: `${parts.join("; ")}.`, ms: readBefore.ms + readAfter.ms };
+}

package/lib/sealed.mjs

@@ -13,6 +13,9 @@ import { timingSafeEqual, webcrypto } from "node:crypto";
 // - Every message: AES-256-GCM under HKDF-SHA256(ECDH(device, daemon)), a fresh 96-bit nonce,
 //   and the direction, device and request id bound as associated data. Requests carry a
 //   timestamp; the daemon refuses stale ones and any request id it has already seen.
+// - The other way round, the daemon asks a paired browser (its screen history): the question goes
+//   "d2b" and the answer "b2d" under the same key, so neither opens as a message of the device's
+//   own calls. The browser applies the same freshness and replay rules (phones.mjs ask).
 // Not provided: forward secrecy (both keys are static). Revoking a device ends its key.
 
 const subtle = webcrypto.subtle;

package/lib/service.mjs

@@ -118,12 +118,14 @@ export function installService({ runtimeRoot, nodePath = process.execPath, platf
   if (platform === "darwin") {
     const plist = servicePath();
     ensureDir(path.dirname(plist));
+    // MallocLargeCache=0: macOS otherwise keeps the large blocks ONNX Runtime frees (a screenshot's OCR held 1.6 GB after
+    // it finished; 255 MB with it off, image-redaction eval).
     fs.writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0"><dict>
   <key>Label</key><string>${LABEL}</string>
   <key>ProgramArguments</key><array><string>${xml(nodePath)}</string><string>${xml(entry)}</string><string>daemon</string></array>
-  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(envPath)}</string></dict>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(envPath)}</string><key>MallocLargeCache</key><string>0</string></dict>
   <key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>ThrottleInterval</key><integer>5</integer>
   <key>StandardOutPath</key><string>${xml(paths.log)}</string><key>StandardErrorPath</key><string>${xml(paths.log)}</string>
 </dict></plist>\n`, { mode: 0o600 });
@@ -145,7 +147,7 @@ export function installService({ runtimeRoot, nodePath = process.execPath, platf
   }
   // Other Node platforms get a ready daemon for this login only. `doctor` reports that
   // login persistence is unavailable rather than pretending it was set.
-  const child = spawn(nodePath, [entry, "daemon"], { detached: true, stdio: "ignore", env: { ...process.env, PATH: envPath } });
+  const child = spawn(nodePath, [entry, "daemon"], { detached: true, stdio: "ignore", env: { ...process.env, PATH: envPath, ...(process.platform === "darwin" ? { MallocLargeCache: "0" } : {}) } });
   child.unref();
   return { manager: "detached", file: null };
 }

package/lib/snippets.mjs

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { nameOf } from "./members.mjs";
+import { repositoryOf } from "./worktrees.mjs";
+
+// Code for an agent that does not run on this computer (Grok Bot, Muse) leaves it only with the person's OK. The agent
+// says what it needs to see (request_snippet); the relay finds it in the thread's folder with its local search, takes
+// the lines around it, masks any secret in them, and holds them. The person shares or keeps them (the buddy, or
+// `tryharness board snippet <id> share|keep`); shared lines are posted in the thread for that agent, kept ones never leave.
+
+const BEFORE = 5;
+const LINES = 40;
+
+export function createSnippets({ store, search, scrub, wake = () => {}, notify = () => {}, log = () => {} }) {
+  const read = (id) => { try { return JSON.parse(store.meta(`snippet:${id}`) || "null"); } catch { return null; } };
+  const save = (snippet) => {
+    store.meta(`snippet:${snippet.id}`, JSON.stringify(snippet));
+    const ids = JSON.parse(store.meta("snippets") || "[]");
+    if (!ids.includes(snippet.id)) store.meta("snippets", JSON.stringify([...ids, snippet.id].slice(-200)));
+  };
+
+  /** A cloud agent's request: { ok, snippet } held for the person, or why there is nothing to hold. */
+  const request = async ({ threadId, agent, about }) => {
+    const thread = store.getTask(threadId);
+    const folder = thread?.kind === "goal" ? thread.goal.workspace : null;
+    if (!folder) return { ok: false, error: "this thread has no folder on the person's computer to show code from" };
+    const words = String(about || "").trim().slice(0, 500);
+    if (!words) return { ok: false, error: "say what you need to see" };
+    const found = await search({ query: words, folder, limit: 1 });
+    const file = found?.ok ? found.files[0] : null;
+    if (!file) return { ok: false, error: found?.error || "nothing in this thread's folder matched that" };
+    const root = repositoryOf(folder)?.root ?? folder;
+    let lines;
+    try { lines = fs.readFileSync(path.join(root, file.path), "utf8").split("\n"); } catch (error) { return { ok: false, error: `${file.path} could not be read (${error.code || error.message})` }; }
+    const from = Math.max(1, file.line - BEFORE), to = Math.min(lines.length, from + LINES - 1);
+    // A secret in the lines stays a placeholder for good: it is never filled back in for an agent elsewhere.
+    const { text, masked } = await scrub(lines.slice(from - 1, to).join("\n"));
+    const snippet = { id: randomUUID(), thread: threadId, agent, about: words, path: file.path, from, to, text, masked, state: "waiting", at: new Date().toISOString() };
+    save(snippet);
+    store.roomPost({ goalId: threadId, author: "harness", kind: "note", text: `${nameOf(agent)} asks to see lines ${from} to ${to} of ${file.path} ("${words.slice(0, 120)}"). They stay on this computer until you share them.` });
+    notify(`${nameOf(agent)} asks to see ${to - from + 1} lines of ${path.basename(file.path)}. Share or keep them in Harness.`, snippet);
+    return { ok: true, snippet: { id: snippet.id, path: file.path, from, to, state: "waiting" }, note: "The person decides whether to share these lines; you are told in the thread." };
+  };
+
+  /** The person shares or keeps a waiting snippet. */
+  const decide = (id, share) => {
+    const snippet = read(id);
+    if (!snippet) return { ok: false, error: "no such request" };
+    if (snippet.state !== "waiting") return { ok: false, error: `already ${snippet.state}` };
+    const done = { ...snippet, state: share ? "shared" : "kept", decidedAt: new Date().toISOString() };
+    save(done);
+    if (share) {
+      const post = store.roomPost({ goalId: snippet.thread, author: "harness", kind: "post", mentions: [snippet.agent],
+        text: `@${snippet.agent} the person shared lines ${snippet.from} to ${snippet.to} of ${snippet.path}${snippet.masked ? ` (${snippet.masked} secret${snippet.masked === 1 ? "" : "s"} in them stay masked)` : ""}:\n\n\`\`\`\n${snippet.text}\n\`\`\`` });
+      wake(snippet.thread, post, [snippet.agent]);
+    } else store.roomPost({ goalId: snippet.thread, author: "harness", kind: "note", text: `The person kept lines ${snippet.from} to ${snippet.to} of ${snippet.path} on this computer.` });
+    log(`snippet ${id}: ${done.state}`);
+    return { ok: true, snippet: { id, state: done.state } };
+  };
+
+  const list = ({ all = false } = {}) => JSON.parse(store.meta("snippets") || "[]").map(read).filter((snippet) => snippet && (all || snippet.state === "waiting"));
+  return { request, decide, list };
+}