tryharness 0.7.22 → 0.7.25

package/lib/activity.mjs

@@ -32,7 +32,9 @@ const base = (token) => path.basename(String(token || "")).replace(/^-/, "");
 export function agentOf(command) {
   if (/\/@anthropic-ai\/claude-code\//.test(command)) return "claude-code";
   const [first, second] = String(command).trim().split(/\s+/);
-  const name = RUNTIMES.has(base(first).replace(/\d+$/, "")) ? base(second) : base(first);
+  const name = RUNTIMES.has(base(first).replace(/\d+$/, ""))
+    ? base(second)
+    : base(first);
   return AGENT_NAMES[name] || null;
 }
 
@@ -40,16 +42,31 @@ export function agentOf(command) {
 export function parsePs(text) {
   const rows = [];
   for (const line of String(text).split("\n")) {
-    const match = line.match(/^\s*(\d+)\s+(\d+)\s+([\d.]+)\s+(\w{3}\s+\w{3}\s+\d+\s+[\d:]+\s+\d{4})\s+(.*)$/);
+    const match = line.match(
+      /^\s*(\d+)\s+(\d+)\s+([\d.]+)\s+(\w{3}\s+\w{3}\s+\d+\s+[\d:]+\s+\d{4})\s+(.*)$/
+    );
     if (!match) continue;
     const startedAt = Date.parse(match[4]);
-    if (Number.isFinite(startedAt)) rows.push({ pid: Number(match[1]), ppid: Number(match[2]), cpu: Number(match[3]), startedAt, command: match[5] });
+    if (Number.isFinite(startedAt))
+      rows.push({
+        pid: Number(match[1]),
+        ppid: Number(match[2]),
+        cpu: Number(match[3]),
+        startedAt,
+        command: match[5],
+      });
   }
   return rows;
 }
 
-const stamp = (value) => (typeof value === "number" ? value : Date.parse(value || "")) || null;
-const textOf = (content) => (typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => part?.text || "").join("") : "");
+const stamp = (value) =>
+  (typeof value === "number" ? value : Date.parse(value || "")) || null;
+const textOf = (content) =>
+  typeof content === "string"
+    ? content
+    : Array.isArray(content)
+      ? content.map((part) => part?.text || "").join("")
+      : "";
 
 /** Whether a transcript's last turn is still open, and when it started, from its newest rows. */
 export function turnOf(agent, rows) {
@@ -57,24 +74,38 @@ export function turnOf(agent, rows) {
     const row = rows[index];
     if (agent === "codex") {
       const kind = row.type === "event_msg" ? row.payload?.type : null;
-      if (kind === "task_started") return { open: true, startedAt: stamp(row.timestamp) };
-      if (kind === "task_complete" || kind === "turn_aborted") return { open: false };
+      if (kind === "task_started")
+        return { open: true, startedAt: stamp(row.timestamp) };
+      if (kind === "task_complete" || kind === "turn_aborted")
+        return { open: false };
     } else if (agent === "pi") {
       const message = row.type === "message" ? row.message : null;
       if (!message) continue;
-      if (message.role === "user") return { open: true, startedAt: stamp(row.timestamp ?? message.timestamp) };
-      if (message.role === "assistant" && message.stopReason !== "toolUse") return { open: false };
+      if (message.role === "user")
+        return {
+          open: true,
+          startedAt: stamp(row.timestamp ?? message.timestamp),
+        };
+      if (message.role === "assistant" && message.stopReason !== "toolUse")
+        return { open: false };
     } else {
-      if (row.isMeta || (row.type !== "user" && row.type !== "assistant")) continue;
+      if (row.isMeta || (row.type !== "user" && row.type !== "assistant"))
+        continue;
       const content = row.message?.content;
       if (row.type === "assistant") {
         if (row.message?.stop_reason === "end_turn") return { open: false };
         continue;
       }
-      if (Array.isArray(content) && content.some((part) => part?.type === "tool_result")) continue;
+      if (
+        Array.isArray(content) &&
+        content.some((part) => part?.type === "tool_result")
+      )
+        continue;
       const text = textOf(content);
-      if (text.startsWith("[Request interrupted by user")) return { open: false };
-      if (text.startsWith("<local-command") || text.startsWith("<command-")) continue;
+      if (text.startsWith("[Request interrupted by user"))
+        return { open: false };
+      if (text.startsWith("<local-command") || text.startsWith("<command-"))
+        continue;
       return { open: true, startedAt: stamp(row.timestamp) };
     }
   }
@@ -91,7 +122,14 @@ function tailRows(file) {
     fs.readSync(fd, buffer, 0, length, size - length);
     const lines = buffer.toString("utf8").split("\n");
     if (length < size) lines.shift();
-    return lines.flatMap((line) => { try { const row = JSON.parse(line); return row && typeof row === "object" ? [row] : []; } catch { return []; } });
+    return lines.flatMap((line) => {
+      try {
+        const row = JSON.parse(line);
+        return row && typeof row === "object" ? [row] : [];
+      } catch {
+        return [];
+      }
+    });
   } catch {
     return [];
   } finally {
@@ -99,24 +137,49 @@ function tailRows(file) {
   }
 }
 
-const stat = (file) => { try { return { file, mtime: fs.statSync(file).mtimeMs }; } catch { return null; } };
+const stat = (file) => {
+  try {
+    return { file, mtime: fs.statSync(file).mtimeMs };
+  } catch {
+    return null;
+  }
+};
 
-const exec = (file, args) => new Promise((resolve) => {
-  execFile(file, args, { encoding: "utf8", maxBuffer: 16 << 20, timeout: 10_000, env: { ...process.env, LC_ALL: "C" } }, (error, stdout) => resolve(error && !stdout ? "" : stdout));
-});
+const exec = (file, args) =>
+  new Promise((resolve) => {
+    execFile(
+      file,
+      args,
+      {
+        encoding: "utf8",
+        maxBuffer: 16 << 20,
+        timeout: 10_000,
+        env: { ...process.env, LC_ALL: "C" },
+      },
+      (error, stdout) => resolve(error && !stdout ? "" : stdout)
+    );
+  });
 
 // Each process's working directory: Claude Code keeps a session's transcript under it.
 async function workingDirectories(pids) {
   const found = new Map();
   if (!pids.length) return found;
   if (process.platform === "linux") {
-    for (const pid of pids) { try { found.set(pid, fs.readlinkSync(`/proc/${pid}/cwd`)); } catch {} }
+    for (const pid of pids) {
+      try {
+        found.set(pid, fs.readlinkSync(`/proc/${pid}/cwd`));
+      } catch {}
+    }
     return found;
   }
-  const lsof = ["/usr/sbin/lsof", "/usr/bin/lsof"].find((file) => fs.existsSync(file));
+  const lsof = ["/usr/sbin/lsof", "/usr/bin/lsof"].find((file) =>
+    fs.existsSync(file)
+  );
   if (!lsof) return found;
   let pid = null;
-  for (const line of (await exec(lsof, ["-a", "-d", "cwd", "-p", pids.join(","), "-Fpn"])).split("\n")) {
+  for (const line of (
+    await exec(lsof, ["-a", "-d", "cwd", "-p", pids.join(","), "-Fpn"])
+  ).split("\n")) {
     if (line.startsWith("p")) pid = Number(line.slice(1));
     else if (line.startsWith("n") && pid) found.set(pid, line.slice(1));
   }
@@ -127,40 +190,111 @@ async function workingDirectories(pids) {
  * Judges the machine from what was read. `processes` are ps rows, `sessions` are transcripts
  * ({ agent, file, mtime, turn, owners: pids of the live agent processes it may belong to }).
  */
-export function judgeActivity({ processes, sessions, runs = [], queued = 0, now = Date.now() }) {
+export function judgeActivity({
+  processes,
+  sessions,
+  runs = [],
+  queued = 0,
+  now = Date.now(),
+}) {
   const children = new Map();
-  for (const row of processes) children.set(row.ppid, [...(children.get(row.ppid) || []), row]);
+  for (const row of processes)
+    children.set(row.ppid, [...(children.get(row.ppid) || []), row]);
   const descendants = (pid) => {
     const found = [];
     const pending = [...(children.get(pid) || [])];
-    while (pending.length) { const row = pending.pop(); found.push(row); pending.push(...(children.get(row.pid) || [])); }
+    while (pending.length) {
+      const row = pending.pop();
+      found.push(row);
+      pending.push(...(children.get(row.pid) || []));
+    }
     return found;
   };
-  const reasons = runs.map((run) => ({ kind: "run", agent: run.agent, id: run.id }));
+  const reasons = runs.map((run) => ({
+    kind: "run",
+    agent: run.agent,
+    id: run.id,
+  }));
   if (queued) reasons.push({ kind: "queued", count: queued });
   const waiting = [];
   for (const session of sessions) {
     if (!session.turn.open) continue;
     const started = session.turn.startedAt || 0;
-    const ranCommand = (row) => { const name = base(row.command.split(/\s+/)[0]); return session.agent === "claude-code" ? SHELLS.has(name) : !HELPERS.has(name); };
-    const command = session.owners.flatMap(descendants).find((row) => row.startedAt >= started && ranCommand(row));
-    if (command) reasons.push({ kind: "command", agent: session.agent, file: session.file, command: command.command.slice(0, 120) });
-    else if (now - session.mtime < QUIET_MS) reasons.push({ kind: "turn", agent: session.agent, file: session.file });
-    else waiting.push({ agent: session.agent, file: session.file, since: new Date(session.mtime).toISOString() });
+    const ranCommand = (row) => {
+      const name = base(row.command.split(/\s+/)[0]);
+      return session.agent === "claude-code"
+        ? SHELLS.has(name)
+        : !HELPERS.has(name);
+    };
+    const command = session.owners
+      .flatMap(descendants)
+      .find((row) => row.startedAt >= started && ranCommand(row));
+    if (command)
+      reasons.push({
+        kind: "command",
+        agent: session.agent,
+        file: session.file,
+        command: command.command.slice(0, 120),
+      });
+    else if (now - session.mtime < QUIET_MS)
+      reasons.push({ kind: "turn", agent: session.agent, file: session.file });
+    else
+      waiting.push({
+        agent: session.agent,
+        file: session.file,
+        since: new Date(session.mtime).toISOString(),
+      });
   }
   for (const agentRow of processes.filter((row) => agentOf(row.command))) {
     const hot = descendants(agentRow.pid).find((row) => row.cpu >= CPU_BUSY);
-    if (hot) reasons.push({ kind: "background", agent: agentOf(agentRow.command), pid: agentRow.pid, command: hot.command.slice(0, 120), cpu: hot.cpu });
+    if (hot)
+      reasons.push({
+        kind: "background",
+        agent: agentOf(agentRow.command),
+        pid: agentRow.pid,
+        command: hot.command.slice(0, 120),
+        cpu: hot.cpu,
+      });
   }
-  return { busy: reasons.length > 0, reasons, waiting, sessions: sessions.map((session) => ({ agent: session.agent, file: session.file, open: session.turn.open })), checkedAt: new Date(now).toISOString() };
+  return {
+    busy: reasons.length > 0,
+    reasons,
+    waiting,
+    sessions: sessions.map((session) => ({
+      agent: session.agent,
+      file: session.file,
+      open: session.turn.open,
+    })),
+    checkedAt: new Date(now).toISOString(),
+  };
 }
 
 /** Reads this machine's agent processes and transcripts and judges them. */
-export async function machineActivity({ runs = [], queued = 0, agents = ["claude-code", "codex", "pi"], now = Date.now() } = {}) {
-  const processes = process.platform === "win32" ? [] : parsePs(await exec(PS, ["-axww", "-o", "pid=,ppid=,pcpu=,lstart=,command="]));
+export async function machineActivity({
+  runs = [],
+  queued = 0,
+  agents = ["claude-code", "codex", "pi"],
+  now = Date.now(),
+} = {}) {
+  const processes =
+    process.platform === "win32"
+      ? []
+      : parsePs(
+          await exec(PS, ["-axww", "-o", "pid=,ppid=,pcpu=,lstart=,command="])
+        );
   const live = processes.filter((row) => agents.includes(agentOf(row.command)));
-  const claudeRecords = (pid) => historyRoots("claude-code").some((root) => fs.existsSync(path.join(root, "..", "sessions", `${pid}.json`)));
-  const cwds = await workingDirectories(live.filter((row) => agentOf(row.command) === "claude-code" && !claudeRecords(row.pid)).map((row) => row.pid));
+  const claudeRecords = (pid) =>
+    historyRoots("claude-code").some((root) =>
+      fs.existsSync(path.join(root, "..", "sessions", `${pid}.json`))
+    );
+  const cwds = await workingDirectories(
+    live
+      .filter(
+        (row) =>
+          agentOf(row.command) === "claude-code" && !claudeRecords(row.pid)
+      )
+      .map((row) => row.pid)
+  );
   const sessions = [];
   for (const agent of agents) {
     const owners = live.filter((row) => agentOf(row.command) === agent);
@@ -176,16 +310,39 @@ export async function machineActivity({ runs = [], queued = 0, agents = ["claude
           const cwd = record?.cwd || cwds.get(row.pid);
           if (!cwd) continue;
           const folder = path.join(root, cwd.replace(/[^a-zA-Z0-9]/g, "-"));
-          const items = record?.sessionId ? [stat(path.join(folder, `${record.sessionId}.jsonl`))].filter(Boolean) : listJsonl(folder).filter((item) => item.mtime >= row.startedAt);
-          for (const item of items) sessions.push({ agent, file: item.file, mtime: item.mtime, turn: turnOf(agent, tailRows(item.file)), owners: [row.pid] });
+          const items = record?.sessionId
+            ? [stat(path.join(folder, `${record.sessionId}.jsonl`))].filter(
+                Boolean
+              )
+            : listJsonl(folder).filter((item) => item.mtime >= row.startedAt);
+          for (const item of items)
+            sessions.push({
+              agent,
+              file: item.file,
+              mtime: item.mtime,
+              turn: turnOf(agent, tailRows(item.file)),
+              owners: [row.pid],
+            });
         }
       } else {
         for (const item of listJsonl(root)) {
-          if (item.mtime >= since) sessions.push({ agent, file: item.file, mtime: item.mtime, turn: turnOf(agent, tailRows(item.file)), owners: owners.map((row) => row.pid) });
+          if (item.mtime >= since)
+            sessions.push({
+              agent,
+              file: item.file,
+              mtime: item.mtime,
+              turn: turnOf(agent, tailRows(item.file)),
+              owners: owners.map((row) => row.pid),
+            });
         }
       }
     }
   }
   // Every agent process, whether or not it is working: the desktop app never pauses the app hosting one.
-  return { ...judgeActivity({ processes, sessions, runs, queued, now }), agentPids: processes.filter((row) => agentOf(row.command)).map((row) => row.pid) };
+  return {
+    ...judgeActivity({ processes, sessions, runs, queued, now }),
+    agentPids: processes
+      .filter((row) => agentOf(row.command))
+      .map((row) => row.pid),
+  };
 }