tryharness 0.7.22 → 0.7.25

package/lib/service.mjs

@@ -9,14 +9,27 @@ import { paths } from "./paths.mjs";
 const LABEL = "ai.tryharness.daemon";
 
 function xml(value) {
-  return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
 }
 
 const WINDOWS_TASK = "tryharness-daemon";
 
 function servicePath(platform = process.platform, homeDir = os.homedir()) {
-  if (platform === "darwin") return path.join(homeDir, "Library", "LaunchAgents", `${LABEL}.plist`);
-  if (platform === "linux") return path.join(homeDir, ".config", "systemd", "user", "tryharness-daemon.service");
+  if (platform === "darwin")
+    return path.join(homeDir, "Library", "LaunchAgents", `${LABEL}.plist`);
+  if (platform === "linux")
+    return path.join(
+      homeDir,
+      ".config",
+      "systemd",
+      "user",
+      "tryharness-daemon.service"
+    );
   if (platform === "win32") return path.join(paths.home, `${WINDOWS_TASK}.xml`);
   return null;
 }
@@ -59,35 +72,76 @@ export function windowsLauncher({ nodePath, entry }) {
 }
 
 function windowsUser(env = process.env) {
-  return env.USERDOMAIN && env.USERNAME ? `${env.USERDOMAIN}\\${env.USERNAME}` : env.USERNAME || os.userInfo().username;
+  return env.USERDOMAIN && env.USERNAME
+    ? `${env.USERDOMAIN}\\${env.USERNAME}`
+    : env.USERNAME || os.userInfo().username;
 }
 
-export function installWindowsTask({ runtimeRoot, nodePath = process.execPath, execute = run, env = process.env }) {
+export function installWindowsTask({
+  runtimeRoot,
+  nodePath = process.execPath,
+  execute = run,
+  env = process.env,
+}) {
   ensureDir(paths.home);
   const entry = path.join(runtimeRoot, "cli.mjs");
   const launcher = path.join(paths.home, `${WINDOWS_TASK}.vbs`);
   const definition = path.join(paths.home, `${WINDOWS_TASK}.xml`);
   fs.writeFileSync(launcher, windowsLauncher({ nodePath, entry }));
   // schtasks reads task XML as UTF-16 with a byte order mark.
-  fs.writeFileSync(definition, "\ufeff" + windowsTaskDefinition({ nodePath, entry, user: windowsUser(env), launcher }), "utf16le");
-  const created = execute("schtasks", ["/Create", "/TN", WINDOWS_TASK, "/XML", definition, "/F"]);
-  if (!created.ok) throw new Error(`could not register the Harness daemon with Task Scheduler: ${created.stderr || created.stdout || created.error}`);
+  fs.writeFileSync(
+    definition,
+    "\ufeff" +
+      windowsTaskDefinition({
+        nodePath,
+        entry,
+        user: windowsUser(env),
+        launcher,
+      }),
+    "utf16le"
+  );
+  const created = execute("schtasks", [
+    "/Create",
+    "/TN",
+    WINDOWS_TASK,
+    "/XML",
+    definition,
+    "/F",
+  ]);
+  if (!created.ok)
+    throw new Error(
+      `could not register the Harness daemon with Task Scheduler: ${created.stderr || created.stdout || created.error}`
+    );
   execute("schtasks", ["/End", "/TN", WINDOWS_TASK]);
   const started = execute("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
-  if (!started.ok) throw new Error(`the Harness daemon task was registered but did not start: ${started.stderr || started.stdout || started.error}`);
+  if (!started.ok)
+    throw new Error(
+      `the Harness daemon task was registered but did not start: ${started.stderr || started.stdout || started.error}`
+    );
   return { manager: "task-scheduler", file: definition };
 }
 
 export function uninstallWindowsTask({ execute = run } = {}) {
   execute("schtasks", ["/End", "/TN", WINDOWS_TASK]);
   execute("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"]);
-  for (const file of [path.join(paths.home, `${WINDOWS_TASK}.xml`), path.join(paths.home, `${WINDOWS_TASK}.vbs`)]) {
-    try { fs.unlinkSync(file); } catch {}
+  for (const file of [
+    path.join(paths.home, `${WINDOWS_TASK}.xml`),
+    path.join(paths.home, `${WINDOWS_TASK}.vbs`),
+  ]) {
+    try {
+      fs.unlinkSync(file);
+    } catch {}
   }
 }
 
 function agentPath() {
-  const dirs = new Set([path.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"]);
+  const dirs = new Set([
+    path.dirname(process.execPath),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+  ]);
   for (const command of ["claude", "codex", "pi", "opencode"]) {
     const found = resolveCommand(command);
     if (found) dirs.add(path.dirname(found));
@@ -97,78 +151,162 @@ function agentPath() {
 
 function retireLegacyBridge() {
   if (process.platform === "darwin") {
-    const legacy = path.join(os.homedir(), "Library", "LaunchAgents", "ai.tryharness.bridge.plist");
+    const legacy = path.join(
+      os.homedir(),
+      "Library",
+      "LaunchAgents",
+      "ai.tryharness.bridge.plist"
+    );
     if (!fs.existsSync(legacy)) return;
     run("launchctl", ["unload", legacy]);
-    try { fs.renameSync(legacy, legacy + ".retired"); } catch {}
+    try {
+      fs.renameSync(legacy, legacy + ".retired");
+    } catch {}
   } else if (process.platform === "linux") {
-    const legacy = path.join(os.homedir(), ".config", "systemd", "user", "tryharness-bridge.service");
+    const legacy = path.join(
+      os.homedir(),
+      ".config",
+      "systemd",
+      "user",
+      "tryharness-bridge.service"
+    );
     if (!fs.existsSync(legacy)) return;
-    run("systemctl", ["--user", "disable", "--now", "tryharness-bridge.service"]);
-    try { fs.renameSync(legacy, legacy + ".retired"); } catch {}
+    run("systemctl", [
+      "--user",
+      "disable",
+      "--now",
+      "tryharness-bridge.service",
+    ]);
+    try {
+      fs.renameSync(legacy, legacy + ".retired");
+    } catch {}
   }
 }
 
-export function installService({ runtimeRoot, nodePath = process.execPath, platform = process.platform, execute = run }) {
+export function installService({
+  runtimeRoot,
+  nodePath = process.execPath,
+  platform = process.platform,
+  execute = run,
+}) {
   ensureDir(paths.home);
   retireLegacyBridge();
   const entry = path.join(runtimeRoot, "cli.mjs");
   const envPath = agentPath();
-  if (platform === "win32") return installWindowsTask({ runtimeRoot, nodePath, execute });
+  if (platform === "win32")
+    return installWindowsTask({ runtimeRoot, nodePath, execute });
   if (platform === "darwin") {
     const plist = servicePath();
     ensureDir(path.dirname(plist));
-    fs.writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
+    // 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 });
+</dict></plist>\n`,
+      { mode: 0o600 }
+    );
     const domain = `gui/${process.getuid()}`;
     run("launchctl", ["bootout", domain, plist]);
     const started = run("launchctl", ["bootstrap", domain, plist]);
-    if (!started.ok) throw new Error(`could not start Harness daemon with launchd: ${started.stderr || started.error}`);
+    if (!started.ok)
+      throw new Error(
+        `could not start Harness daemon with launchd: ${started.stderr || started.error}`
+      );
     run("launchctl", ["kickstart", "-k", `${domain}/${LABEL}`]);
     return { manager: "launchd", file: plist };
   }
   if (platform === "linux") {
     const unit = servicePath();
     ensureDir(path.dirname(unit));
-    fs.writeFileSync(unit, `[Unit]\nDescription=Harness local daemon\nAfter=network-online.target\n\n[Service]\nExecStart=${JSON.stringify(nodePath)} ${JSON.stringify(entry)} daemon\nEnvironment=PATH=${envPath}\nRestart=always\nRestartSec=5\nStandardOutput=append:${paths.log}\nStandardError=append:${paths.log}\n\n[Install]\nWantedBy=default.target\n`, { mode: 0o600 });
+    fs.writeFileSync(
+      unit,
+      `[Unit]\nDescription=Harness local daemon\nAfter=network-online.target\n\n[Service]\nExecStart=${JSON.stringify(nodePath)} ${JSON.stringify(entry)} daemon\nEnvironment=PATH=${envPath}\nRestart=always\nRestartSec=5\nStandardOutput=append:${paths.log}\nStandardError=append:${paths.log}\n\n[Install]\nWantedBy=default.target\n`,
+      { mode: 0o600 }
+    );
     const reload = run("systemctl", ["--user", "daemon-reload"]);
-    const started = run("systemctl", ["--user", "enable", "--now", "tryharness-daemon.service"]);
-    if (!reload.ok || !started.ok) throw new Error(`could not start Harness daemon with systemd: ${started.stderr || reload.stderr}`);
+    const started = run("systemctl", [
+      "--user",
+      "enable",
+      "--now",
+      "tryharness-daemon.service",
+    ]);
+    if (!reload.ok || !started.ok)
+      throw new Error(
+        `could not start Harness daemon with systemd: ${started.stderr || reload.stderr}`
+      );
     return { manager: "systemd", file: unit };
   }
   // 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 };
 }
 
-export function uninstallService({ platform = process.platform, execute = run } = {}) {
+export function uninstallService({
+  platform = process.platform,
+  execute = run,
+} = {}) {
   const file = servicePath(platform);
-  if (platform === "win32") { uninstallWindowsTask({ execute }); return; }
+  if (platform === "win32") {
+    uninstallWindowsTask({ execute });
+    return;
+  }
   if (platform === "darwin" && file) {
     run("launchctl", ["bootout", `gui/${process.getuid()}`, file]);
-    try { fs.unlinkSync(file); } catch {}
+    try {
+      fs.unlinkSync(file);
+    } catch {}
   } else if (platform === "linux" && file) {
-    run("systemctl", ["--user", "disable", "--now", "tryharness-daemon.service"]);
-    try { fs.unlinkSync(file); } catch {}
+    run("systemctl", [
+      "--user",
+      "disable",
+      "--now",
+      "tryharness-daemon.service",
+    ]);
+    try {
+      fs.unlinkSync(file);
+    } catch {}
     run("systemctl", ["--user", "daemon-reload"]);
   }
 }
 
-export function serviceInfo({ platform = process.platform, execute = run } = {}) {
+export function serviceInfo({
+  platform = process.platform,
+  execute = run,
+} = {}) {
   const file = servicePath(platform);
   if (platform === "win32") {
     // Installed means the task is registered, not merely that its files exist.
-    const registered = Boolean(file && fs.existsSync(file)) && execute("schtasks", ["/Query", "/TN", WINDOWS_TASK]).ok;
+    const registered =
+      Boolean(file && fs.existsSync(file)) &&
+      execute("schtasks", ["/Query", "/TN", WINDOWS_TASK]).ok;
     return { manager: "task-scheduler", installed: registered, file };
   }
-  return { manager: platform === "darwin" ? "launchd" : platform === "linux" ? "systemd" : "detached", installed: Boolean(file && fs.existsSync(file)), file };
+  return {
+    manager:
+      platform === "darwin"
+        ? "launchd"
+        : platform === "linux"
+          ? "systemd"
+          : "detached",
+    installed: Boolean(file && fs.existsSync(file)),
+    file,
+  };
 }

package/lib/snippets.mjs

@@ -0,0 +1,140 @@
+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 };
+}