tryharness 0.7.22 → 0.7.25

package/lib/desktop.mjs

@@ -21,9 +21,11 @@ const downloads = () => path.join(paths.home, "desktop-download");
 /** Whether version `a` is newer than `b`: x.y.z, a prerelease (0.7.13-local.ab12) before its release. */
 export function newerVersion(a, b) {
   const parse = (v) => /^(\d+)\.(\d+)\.(\d+)(-.+)?$/.exec(String(v ?? ""));
-  const x = parse(a), y = parse(b);
+  const x = parse(a),
+    y = parse(b);
   if (!x || !y) return Boolean(x);
-  for (let i = 1; i <= 3; i++) if (Number(x[i]) !== Number(y[i])) return Number(x[i]) > Number(y[i]);
+  for (let i = 1; i <= 3; i++)
+    if (Number(x[i]) !== Number(y[i])) return Number(x[i]) > Number(y[i]);
   return !x[4] && Boolean(y[4]);
 }
 
@@ -32,18 +34,36 @@ export function newerVersion(a, b) {
  * Harness's home. The download must match the checksum npm publishes for it. Null when there is nothing newer,
  * nothing for this machine, or npm cannot be reached: setup goes on with what it has.
  */
-export async function latestDesktop({ than, platform = process.platform, arch = process.arch, registry = REGISTRY }) {
+export async function latestDesktop({
+  than,
+  platform = process.platform,
+  arch = process.arch,
+  registry = REGISTRY,
+}) {
   try {
-    const response = await fetch(`${registry}/${desktopPackageName(platform, arch)}/latest`);
+    const response = await fetch(
+      `${registry}/${desktopPackageName(platform, arch)}/latest`
+    );
     if (!response.ok) return null;
     const meta = await response.json();
     const tarball = String(meta.dist?.tarball ?? "");
-    if (!meta.harnessDesktop || !newerVersion(meta.version, than) || !tarball.startsWith(`${registry}/`)) return null;
+    if (
+      !meta.harnessDesktop ||
+      !newerVersion(meta.version, than) ||
+      !tarball.startsWith(`${registry}/`)
+    )
+      return null;
     const download = await fetch(tarball);
     if (!download.ok) return null;
     const bytes = Buffer.from(await download.arrayBuffer());
-    const [algorithm, digest] = String(meta.dist.integrity ?? "").split(/-(.*)/s);
-    if (algorithm !== "sha512" || createHash("sha512").update(bytes).digest("base64") !== digest) return null;
+    const [algorithm, digest] = String(meta.dist.integrity ?? "").split(
+      /-(.*)/s
+    );
+    if (
+      algorithm !== "sha512" ||
+      createHash("sha512").update(bytes).digest("base64") !== digest
+    )
+      return null;
     fs.rmSync(downloads(), { recursive: true, force: true });
     ensureDir(downloads());
     const file = path.join(downloads(), "package.tgz");
@@ -61,67 +81,135 @@ export async function latestDesktop({ than, platform = process.platform, arch =
  * over a newer one (a local build stays). Where it is and whether it changed, or null when this machine has none.
  * HARNESS_DESKTOP_APP installs that app as it is.
  */
-export async function setupDesktop({ sourceRoot, env = process.env, platform = process.platform, arch = process.arch, registry = REGISTRY, execute = run }) {
+export async function setupDesktop({
+  sourceRoot,
+  env = process.env,
+  platform = process.platform,
+  arch = process.arch,
+  registry = REGISTRY,
+  execute = run,
+}) {
   const bundled = desktopSource({ sourceRoot, env, platform, arch });
-  const install = (source) => installDesktop({ source, target: desktopTarget({ source, env, platform }), platform, execute });
+  const install = (source) =>
+    installDesktop({
+      source,
+      target: desktopTarget({ source, env, platform }),
+      platform,
+      execute,
+    });
   if (env.HARNESS_DESKTOP_APP) return bundled && install(bundled);
   const installed = readJson(marker(), {});
-  const have = installed.path && fs.existsSync(installed.path) ? installed : null;
-  const than = newerVersion(have?.version, bundled?.version) ? have.version : bundled?.version ?? have?.version;
+  const have =
+    installed.path && fs.existsSync(installed.path) ? installed : null;
+  const than = newerVersion(have?.version, bundled?.version)
+    ? have.version
+    : (bundled?.version ?? have?.version);
   const latest = await latestDesktop({ than, platform, arch, registry });
   const source = latest ?? bundled;
   try {
-    if (have && (!source || newerVersion(have.version, source.version))) return { target: have.path, updated: false };
+    if (have && (!source || newerVersion(have.version, source.version)))
+      return { target: have.path, updated: false };
     return source && install(source);
   } finally {
     if (latest) fs.rmSync(downloads(), { recursive: true, force: true });
   }
 }
 
-export function desktopPackageName(platform = process.platform, arch = process.arch) {
+export function desktopPackageName(
+  platform = process.platform,
+  arch = process.arch
+) {
   return `tryharness-desktop-${platform}-${arch}`;
 }
 
 /** The app inside this machine's platform package, or null when there is none for it. */
-export function desktopSource({ sourceRoot, env = process.env, platform = process.platform, arch = process.arch }) {
-  if (env.HARNESS_DESKTOP_APP) return { app: path.resolve(env.HARNESS_DESKTOP_APP), version: env.HARNESS_DESKTOP_VERSION || "dev" };
+export function desktopSource({
+  sourceRoot,
+  env = process.env,
+  platform = process.platform,
+  arch = process.arch,
+}) {
+  if (env.HARNESS_DESKTOP_APP)
+    return {
+      app: path.resolve(env.HARNESS_DESKTOP_APP),
+      version: env.HARNESS_DESKTOP_VERSION || "dev",
+    };
   let packageJson;
-  try { packageJson = createRequire(path.join(sourceRoot, "package.json")).resolve(`${desktopPackageName(platform, arch)}/package.json`); }
-  catch { return null; }
+  try {
+    packageJson = createRequire(path.join(sourceRoot, "package.json")).resolve(
+      `${desktopPackageName(platform, arch)}/package.json`
+    );
+  } catch {
+    return null;
+  }
   const meta = readJson(packageJson, {});
-  const app = path.join(path.dirname(packageJson), String(meta.harnessDesktop || ""));
-  return meta.harnessDesktop && fs.existsSync(app) ? { app, version: String(meta.version) } : null;
+  const app = path.join(
+    path.dirname(packageJson),
+    String(meta.harnessDesktop || "")
+  );
+  return meta.harnessDesktop && fs.existsSync(app)
+    ? { app, version: String(meta.version) }
+    : null;
 }
 
 /** Where the app is kept. On a Mac that is ~/Applications, so Spotlight and Launchpad find it. */
-export function desktopTarget({ source, env = process.env, platform = process.platform, homeDir = os.homedir() }) {
+export function desktopTarget({
+  source,
+  env = process.env,
+  platform = process.platform,
+  homeDir = os.homedir(),
+}) {
   const file = path.basename(source.app);
-  if (platform === "darwin" && !env.HARNESS_HOME) return path.join(homeDir, "Applications", file);
+  if (platform === "darwin" && !env.HARNESS_HOME)
+    return path.join(homeDir, "Applications", file);
   return path.join(paths.home, "desktop", file);
 }
 
 function executables(target, platform) {
   if (platform === "darwin") {
     const dir = path.join(target, "Contents", "MacOS");
-    return fs.existsSync(dir) ? fs.readdirSync(dir).map((name) => path.join(dir, name)) : [];
+    return fs.existsSync(dir)
+      ? fs.readdirSync(dir).map((name) => path.join(dir, name))
+      : [];
   }
   return [target];
 }
 
-export function quitDesktop({ target, platform = process.platform, execute = run }) {
-  if (platform === "win32") { execute("taskkill", ["/F", "/IM", path.basename(target)]); return; }
+export function quitDesktop({
+  target,
+  platform = process.platform,
+  execute = run,
+}) {
+  if (platform === "win32") {
+    execute("taskkill", ["/F", "/IM", path.basename(target)]);
+    return;
+  }
   const exes = executables(target, platform);
   for (const exe of exes) execute("pkill", ["-f", exe]);
   // Opening it again before the old one has gone fails on macOS (LaunchServices error -600).
-  for (let i = 0; i < 50 && exes.some((exe) => execute("pgrep", ["-f", exe]).ok); i++) {
+  for (
+    let i = 0;
+    i < 50 && exes.some((exe) => execute("pgrep", ["-f", exe]).ok);
+    i++
+  ) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
   }
 }
 
 /** Copies the app into place unless this version is already there. Returns where it is. */
-export function installDesktop({ source, target, platform = process.platform, execute = run }) {
+export function installDesktop({
+  source,
+  target,
+  platform = process.platform,
+  execute = run,
+}) {
   const installed = readJson(marker(), {});
-  if (installed.version === source.version && installed.path === target && fs.existsSync(target)) return { target, updated: false };
+  if (
+    installed.version === source.version &&
+    installed.path === target &&
+    fs.existsSync(target)
+  )
+    return { target, updated: false };
   // Replacing a running app's files under it is how it crashes; it is quit first and reopened after.
   if (fs.existsSync(target)) quitDesktop({ target, platform, execute });
   ensureDir(path.dirname(target));
@@ -137,12 +225,19 @@ export function installDesktop({ source, target, platform = process.platform, ex
 }
 
 /** Whether this login can show a window at all: not a server reached over SSH. */
-export function canShowDesktop({ env = process.env, platform = process.platform }) {
+export function canShowDesktop({
+  env = process.env,
+  platform = process.platform,
+}) {
   if (platform === "linux") return Boolean(env.DISPLAY || env.WAYLAND_DISPLAY);
   return platform === "darwin" || platform === "win32";
 }
 
-export function openDesktop({ target, platform = process.platform, execute = run }) {
+export function openDesktop({
+  target,
+  platform = process.platform,
+  execute = run,
+}) {
   if (platform === "darwin") {
     // Just after the old copy quits, LaunchServices can still refuse (error -600) for a moment.
     let opened = execute("open", [target]);
@@ -150,7 +245,8 @@ export function openDesktop({ target, platform = process.platform, execute = run
       Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
       opened = execute("open", [target]);
     }
-    if (!opened.ok) throw new Error(opened.stderr.trim() || opened.error || "open failed");
+    if (!opened.ok)
+      throw new Error(opened.stderr.trim() || opened.error || "open failed");
     return;
   }
   const child = spawn(target, [], { detached: true, stdio: "ignore" });
@@ -159,11 +255,29 @@ export function openDesktop({ target, platform = process.platform, execute = run
 }
 
 /** Disconnecting stops the app and takes it out of login items; the app itself stays. */
-export function retireDesktop({ platform = process.platform, execute = run, homeDir = os.homedir() }) {
+export function retireDesktop({
+  platform = process.platform,
+  execute = run,
+  homeDir = os.homedir(),
+}) {
   const installed = readJson(marker(), {});
-  if (installed.path) quitDesktop({ target: installed.path, platform, execute });
+  if (installed.path)
+    quitDesktop({ target: installed.path, platform, execute });
   // Where the app's own login item lives (tauri-plugin-autostart, named after the product).
-  if (platform === "darwin") fs.rmSync(path.join(homeDir, "Library", "LaunchAgents", "Harness.plist"), { force: true });
-  else if (platform === "linux") fs.rmSync(path.join(homeDir, ".config", "autostart", "Harness.desktop"), { force: true });
-  else if (platform === "win32") execute("reg", ["delete", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run", "/v", "Harness", "/f"]);
+  if (platform === "darwin")
+    fs.rmSync(path.join(homeDir, "Library", "LaunchAgents", "Harness.plist"), {
+      force: true,
+    });
+  else if (platform === "linux")
+    fs.rmSync(path.join(homeDir, ".config", "autostart", "Harness.desktop"), {
+      force: true,
+    });
+  else if (platform === "win32")
+    execute("reg", [
+      "delete",
+      "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run",
+      "/v",
+      "Harness",
+      "/f",
+    ]);
 }

package/lib/digest.mjs

@@ -0,0 +1,81 @@
+import { nameOf } from "./members.mjs";
+
+// "While you were away": what happened on the board since a moment, built by code from the board's own records (no
+// model writes it, so every name, number and verdict in it is one the board holds). Threads with finished work and what
+// each run's own session shows, questions waiting for the person, posts the guard held, watches that went off, and what
+// the overnight learner kept. The buddy shows it when the person comes back.
+
+const MAX_THREADS = 6;
+const clip = (text, length) => {
+  const flat = String(text || "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return flat.length > length ? `${flat.slice(0, length - 1)}…` : flat;
+};
+
+/** { since, lines, threads, empty }: lines are plain sentences, threads their ids for opening them. */
+export function digestSince(
+  store,
+  since,
+  { alerts = [], learning = null, receiptOf = () => null } = {}
+) {
+  const lines = [];
+  const threads = [];
+  for (const thread of store.goals({ all: true })) {
+    if (thread.updated_at <= since) continue;
+    const posts = store
+      .roomPosts(thread.id, 0, 500)
+      .filter((post) => post.created_at > since);
+    const results = posts.filter(
+      (post) =>
+        post.author !== "user" &&
+        post.author !== thread.goal.facilitator &&
+        (post.kind === "post" || post.kind === "result")
+    );
+    const questions = posts.filter((post) => post.kind === "question");
+    const held = store.heldCount(thread.id, since);
+    const runs = store
+      .threadRuns(thread.id)
+      .filter((run) => run.reported_at && run.reported_at > since);
+    if (!results.length && !questions.length && !runs.length) continue;
+    const parts = [];
+    const finished = runs.filter((run) => run.status === "done"),
+      failed = runs.filter((run) => run.status === "failed");
+    if (finished.length)
+      parts.push(
+        `${[...new Set(finished.map((run) => nameOf(run.target_agent)))].join(" and ")} finished ${finished.length === 1 ? "a turn" : `${finished.length} turns`}`
+      );
+    if (failed.length) parts.push(`${failed.length} failed`);
+    const checks = runs
+      .map((run) => ({ agent: run.target_agent, ...receiptOf(run.id) }))
+      .filter((check) => check.verdict && check.verdict !== "no changes");
+    const untested = checks.filter((check) => check.verdict !== "tested");
+    if (checks.length)
+      parts.push(
+        untested.length
+          ? `${untested.map((check) => `${nameOf(check.agent)}: ${check.verdict}`).join("; ")}`
+          : "its changes were tested"
+      );
+    if (questions.length)
+      parts.push(
+        `a question waits for you: "${clip(questions.at(-1).text, 90)}"`
+      );
+    if (held)
+      parts.push(
+        `${held} post${held === 1 ? "" : "s"} held because ${held === 1 ? "it reads" : "they read"} like orders to your agents`
+      );
+    if (!finished.length && !failed.length && results.length)
+      parts.unshift(
+        `${[...new Set(results.map((post) => nameOf(post.author)))].join(" and ")} answered`
+      );
+    lines.push(`"${clip(thread.objective, 60)}": ${parts.join("; ")}.`);
+    threads.push(thread.id);
+    if (threads.length >= MAX_THREADS) break;
+  }
+  for (const alert of alerts) lines.push(`Watch: ${alert.text}`);
+  if (learning?.kept && learning.at > since)
+    lines.push(
+      `Learned from ${learning.runs} runs: briefs now hold the files agents went on to change ${Math.round(learning.recallAt10.candidate * 100)}% of the time (was ${Math.round(Math.max(learning.recallAt10.default, learning.recallAt10.current ?? 0) * 100)}%).`
+    );
+  return { since, lines, threads, empty: !lines.length };
+}

package/lib/environment.mjs

@@ -0,0 +1,180 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+// What the relay can see of the person's computer without asking for any permission: which app is in front and how
+// long since they last touched the keyboard or mouse (macOS: lsappinfo and the HID idle timer; Linux under X11 when
+// xprintidle and xdotool are installed; nothing elsewhere), and the state of each repository the swarm works in (its
+// branch, files changed and not committed, and how long ago). The front app and idle time stay on this computer: they
+// time the buddy's digest and keep it quiet while the person is in a call. Window titles are never read.
+
+const PERSON_TTL_MS = 15_000;
+const REPO_TTL_MS = 10_000;
+const CALL_APPS =
+  /^(?:zoom\.us|FaceTime|Microsoft Teams|Webex|Slack Huddle|Discord|Around|Google Meet|Tuple|Pop)$/i;
+
+const run = (command, args, options = {}) => {
+  try {
+    const out = spawnSync(command, args, {
+      encoding: "utf8",
+      timeout: 2_000,
+      ...options,
+    });
+    return out.status === 0 ? out.stdout : null;
+  } catch {
+    return null;
+  }
+};
+
+/** The front app's name and seconds since the last input, or nulls where the OS can't say without a permission. */
+export function readPerson({
+  platform = process.platform,
+  exec = run,
+  file = process.env.HARNESS_PRESENCE_FILE,
+} = {}) {
+  // Tests stand in for the OS: a JSON file { app, idleSeconds }, read instead of it (tests/e2e/desktop-local.mts).
+  if (file) {
+    try {
+      const read = JSON.parse(fs.readFileSync(file, "utf8"));
+      return {
+        app: typeof read.app === "string" ? read.app : null,
+        idleSeconds: Number.isFinite(read.idleSeconds)
+          ? read.idleSeconds
+          : null,
+      };
+    } catch {
+      return { app: null, idleSeconds: null };
+    }
+  }
+  if (platform === "darwin") {
+    const asn = exec("lsappinfo", ["front"])?.trim();
+    const app = asn
+      ? (exec("lsappinfo", ["info", "-only", "name", asn])?.match(
+          /"LSDisplayName"\s*=\s*"([^"]*)"/
+        )?.[1] ?? null)
+      : null;
+    const idle = exec("ioreg", [
+      "-c",
+      "IOHIDSystem",
+      "-d",
+      "4",
+      "-r",
+      "-k",
+      "HIDIdleTime",
+    ])?.match(/"HIDIdleTime"\s*=\s*(\d+)/)?.[1];
+    return { app, idleSeconds: idle ? Math.round(Number(idle) / 1e9) : null };
+  }
+  if (platform === "linux" && process.env.DISPLAY) {
+    const idle = exec("xprintidle", []);
+    const pid = exec("xdotool", ["getactivewindow", "getwindowpid"])?.trim();
+    let app = null;
+    try {
+      if (pid) app = fs.readFileSync(`/proc/${pid}/comm`, "utf8").trim();
+    } catch {}
+    return { app, idleSeconds: idle ? Math.round(Number(idle) / 1000) : null };
+  }
+  return { app: null, idleSeconds: null };
+}
+
+/** A repository's branch and the files changed in it and not committed, newest change first. */
+export function readRepository(folder, { exec = run } = {}) {
+  const top = exec("git", ["rev-parse", "--show-toplevel"], {
+    cwd: folder,
+  })?.trim();
+  if (!top) return null;
+  const branch =
+    exec("git", ["branch", "--show-current"], { cwd: top })?.trim() || null;
+  const status =
+    exec(
+      "git",
+      ["status", "--porcelain=v1", "-z", "--untracked-files=normal"],
+      { cwd: top }
+    ) ?? "";
+  const changed = [];
+  const entries = status.split("\0");
+  for (let i = 0; i < entries.length; i += 1) {
+    const entry = entries[i];
+    if (entry.length < 4) continue;
+    // A rename's old path follows it.
+    if (entry[0] === "R" || entry[0] === "C") i += 1;
+    const rel = entry.slice(3);
+    let mtime = null;
+    try {
+      mtime = fs.statSync(path.join(top, rel)).mtimeMs;
+    } catch {}
+    changed.push({
+      path: rel,
+      state:
+        entry.slice(0, 2).trim() === "??"
+          ? "new"
+          : entry[1] === "D" || entry[0] === "D"
+            ? "deleted"
+            : "changed",
+      at: mtime,
+    });
+  }
+  changed.sort((a, b) => (b.at ?? 0) - (a.at ?? 0));
+  const last = exec("git", ["log", "-1", "--format=%ct%x00%s"], {
+    cwd: top,
+  })?.split("\0");
+  return {
+    root: top,
+    branch,
+    changed,
+    lastCommit: last?.[0]
+      ? {
+          at: Number(last[0]) * 1000,
+          subject: String(last[1] || "")
+            .trim()
+            .slice(0, 200),
+        }
+      : null,
+  };
+}
+
+export function createEnvironment({
+  platform = process.platform,
+  exec = run,
+} = {}) {
+  let person = null;
+  const repos = new Map();
+  return {
+    /** { app, idleSeconds, inCall, at }: never sent off this computer. */
+    person() {
+      if (
+        !person ||
+        Date.now() - person.at >
+          (process.env.HARNESS_PRESENCE_FILE ? 0 : PERSON_TTL_MS)
+      ) {
+        const read = readPerson({ platform, exec });
+        person = {
+          ...read,
+          inCall: Boolean(read.app && CALL_APPS.test(read.app)),
+          at: Date.now(),
+        };
+      }
+      return person;
+    },
+    repository(folder) {
+      const cached = repos.get(folder);
+      if (cached && Date.now() - cached.at < REPO_TTL_MS) return cached.value;
+      const value =
+        folder && fs.existsSync(folder)
+          ? readRepository(folder, { exec })
+          : null;
+      repos.set(folder, { at: Date.now(), value });
+      if (repos.size > 200) repos.delete(repos.keys().next().value);
+      return value;
+    },
+    /** Minutes since a file in folder last changed, from its uncommitted files or its last commit; null when unknown. */
+    lastChanged(folder, now = Date.now()) {
+      const repo = this.repository(folder);
+      if (!repo) return null;
+      const newest = Math.max(
+        repo.changed[0]?.at ?? 0,
+        repo.lastCommit?.at ?? 0
+      );
+      return newest ? Math.max(0, Math.round((now - newest) / 60_000)) : null;
+    },
+  };
+}