npm - agent-dag - Versions diffs - 1.34.5 → 1.35.0 - Mend

agent-dag 1.34.5 → 1.35.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md +3 -1
package/bin/deck.js +13 -3
package/dist/web/assets/{index-CDgBtXXg.js → index-CMZYhML1.js} +1 -1
package/dist/web/index.html +1 -1
package/hook/hook.js +64 -21
package/package.json +1 -1
package/src/server/index.mjs +93 -3
package/src/server/log-writer.mjs +34 -19

package/dist/web/index.html CHANGED Viewed

@@ -40,7 +40,7 @@
         document.documentElement.setAttribute("data-theme", stored === "light" ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-CDgBtXXg.js"></script>
+    <script type="module" crossorigin src="/assets/index-CMZYhML1.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CRPobBZf.css">
   </head>
   <body>

package/hook/hook.js CHANGED Viewed

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 // agent-dag hook forwarder. Invoked by Claude Code or Codex CLI as a command
 // hook. Reads stdin (event JSON), tags it with the provider passed via
-// `--provider <name>`, finds the matching agent-dag server via per-workspace
-// discovery files in <claude config dir>/agent-dag/, makes that server prove it
-// is the deck the file describes, and POSTs the payload. Dead instances are
-// cleaned up.
+// `--provider <name>`, finds every agent-dag server whose workspace contains the
+// session — via the discovery files in <claude config dir>/agent-dag/ — makes
+// each one prove it is the deck its file describes, and POSTs the payload. Dead
+// instances are cleaned up.
 "use strict";
 const fs = require("fs");
@@ -86,6 +86,36 @@ function cwdInWorkspace(cwd, workspace, platform = process.platform) {
   return a.startsWith(b.endsWith(p.sep) ? b : b + p.sep);
 }
+/**
+ * Does a deck scoped to `workspace` capture a session running in `cwd`? This is
+ * the whole of what `--workspace` means, and it is a question about ONE deck: it
+ * asks nothing about the others that may also be up, so a deck's answer never
+ * depends on who else is running.
+ *
+ * An empty workspace is the default — machine-wide — and captures everything.
+ * It is answered before cwdInWorkspace rather than passed to it because
+ * p.resolve("") is the resolving process's own cwd, which here is the agent's,
+ * so an unscoped deck would be silently scoped to whatever directory the user
+ * happened to run their agent in.
+ *
+ * A session that never said where it runs is inside no workspace, so only an
+ * unscoped deck sees it. Unreachable from main(), which exits before this on a
+ * payload with no cwd — it is here because the rule has to be stated the same
+ * way on both sides to be pinned against the other one.
+ *
+ * src/server/log-writer.mjs answers this same question, for the sessions the
+ * server builds itself out of Codex's rollout files, under the name
+ * codexCwdInWorkspace — this script is copied out of the package and run
+ * standalone, so it cannot import that copy. A test walks one table of paths
+ * through both: a disagreement between them is `--workspace` meaning two
+ * different things depending on which CLI produced the session.
+ */
+function capturesSession(cwd, workspace, platform = process.platform) {
+  if (!workspace || typeof workspace !== "string") return true;
+  if (!cwd || typeof cwd !== "string") return false;
+  return cwdInWorkspace(cwd, workspace, platform);
+}
 function isAlive(pid) {
   try { process.kill(pid, 0); return true; }
   catch (e) { return e && e.code === "EPERM"; }
@@ -315,7 +345,24 @@ function main() {
     } catch { return process.exit(0); }
     if (!files.length) return process.exit(0);
-    const matches = [];
+    // Every deck whose workspace contains this cwd, and nothing else decides it.
+    //
+    // This used to sort the matches by how long each deck's workspace path was
+    // and deliver only to the longest — so a deck scoped to /Users/x/proj TOOK
+    // that tree's sessions away from a machine-wide deck, which then sat there
+    // showing nothing while `--all` promised it captured every session on this
+    // machine. Nothing documented that, and the server's own Codex capture never
+    // did it: each deck tails the rollout files itself and evaluates its own
+    // workspace, so a Codex session inside a scoped tree appeared on both decks
+    // while the Claude session beside it appeared on one. One flag, one path,
+    // two answers.
+    //
+    // The fan-out is the documented meaning and the one kept: `--workspace` says
+    // which sessions a deck captures, not which sessions it takes from the decks
+    // around it. It is also what electWriters below already assumes — several
+    // decks drawing one event is the case it exists to keep from being written
+    // to one log several times.
+    const targets = [];
     for (const file of files) {
       let d;
       try { d = JSON.parse(fs.readFileSync(path.join(DIR, file), "utf8")); } catch { continue; }
@@ -329,29 +376,25 @@ function main() {
         continue;
       }
-      if (d.workspace === "") {
-        matches.push({ d, wsLen: 0 });
-        continue;
-      }
-      const ws = normPath(d.workspace);
-      if (cwdInWorkspace(resolvedCwd, ws)) {
-        matches.push({ d, wsLen: ws.length });
-      }
+      // "" is machine-wide and must never reach normPath: resolving it would
+      // produce this hook's own cwd — the agent's — and scope a deck that asked
+      // for no scope at all. Any other spelling is canonicalized here, which is
+      // now a second pass over a path bin/deck.js already canonicalized before
+      // publishing it — kept because a deck old enough to have published a
+      // relative one is still entitled to its events.
+      const ws = d.workspace === "" ? "" : normPath(d.workspace);
+      if (capturesSession(resolvedCwd, ws)) targets.push(d);
     }
-    if (!matches.length) return process.exit(0);
-    matches.sort((a, b) => b.wsLen - a.wsLen);
-    const bestLen = matches[0].wsLen;
-    const targets = matches.filter(m => m.wsLen === bestLen);
+    if (!targets.length) return process.exit(0);
     // One deck per events log records this event; the others only draw it.
-    const writers = electWriters(targets.map(m => m.d));
+    const writers = electWriters(targets);
     let pending = targets.length;
     const done = () => { if (--pending <= 0) process.exit(0); };
-    for (const { d } of targets) deliver(d, taggedInput, writers.has(d), done);
+    for (const d of targets) deliver(d, taggedInput, writers.has(d), done);
   });
 }
@@ -360,5 +403,5 @@ function main() {
 // require() it exports the rules it decides by — matching, election, the
 // handshake — and starts nothing, which is what lets them be tested without a
 // 1.5s exit timer in the test runner.
-module.exports = { cwdInWorkspace, foldsCase, electWriters, challengeProof, requiresProof };
+module.exports = { capturesSession, cwdInWorkspace, foldsCase, electWriters, challengeProof, requiresProof };
 if (require.main === module) main();

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.34.5",
+  "version": "1.35.0",
   "description": "Live deck of Claude Code and Codex agents — watch parallel subagents fork, call tools, and return on one calm canvas. Also available as npx ccdeck and npx agent-dag.",
   "type": "module",
   "bin": {

package/src/server/index.mjs CHANGED Viewed

@@ -2,7 +2,7 @@
 // Single-file pure Node HTTP server, zero deps.
 import { createServer } from "node:http";
 import { readFile, stat, mkdir, appendFile, open, truncate, readdir, unlink } from "node:fs/promises";
-import { createReadStream, existsSync, readFileSync } from "node:fs";
+import { createReadStream, existsSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { extname, join, resolve, dirname as pdirname } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -785,12 +785,17 @@ function maybeResolveCodex(payload) {
 // object {timestamp, type, payload}; we map the relevant ones to the same
 // synthetic hook payloads the reducer already understands:
 //   session_meta                       → SessionStart
-//   event_msg/user_message             → UserPromptSubmit
+//   event_msg/user_message             → UserPromptSubmit (Codex ≤ 0.144)
+//   event_msg/item_completed/UserMessage → UserPromptSubmit (Codex ≥ 0.147)
 //   response_item/function_call        → PreToolUse
 //   response_item/function_call_output → PostToolUse
 //   event_msg/token_count              → UsageObserved
 //   event_msg/task_started (+window)   → ModelObserved (context window)
+//   event_msg/task_complete            → Stop (the turn finished)
+//   event_msg/turn_aborted             → Stop (the turn was interrupted)
 //   turn_context / response_item.model → model snapshot (ModelObserved on change)
+// There is deliberately no SessionEnd here: Codex writes no session-close
+// record, so the end of a SESSION is still inferred by sweepStaleSessions.
 // Events are emitted with source "codex" so pushEvent skips the Claude-only
 // transcript enrichment (which needs transcript_path / hook events) but still
 // broadcasts them exactly like a hook event, and persists them when this deck is
@@ -890,10 +895,27 @@ async function readCodexHeader(path) {
   return null;
 }
+/**
+ * The human's prompt out of a 0.147-era `item_completed` item.
+ *
+ * `item.content` is an array of parts — every UserMessage observed carries a
+ * single `{ type: "text", text, text_elements }` — so the parts are joined
+ * rather than indexed, and a part with no string `text` contributes nothing
+ * instead of printing "undefined" into the prompt the card shows.
+ */
+function codexItemText(item) {
+  const parts = Array.isArray(item && item.content) ? item.content : [];
+  return parts.map(p => (p && typeof p.text === "string" ? p.text : "")).join("");
+}
 // Map one parsed rollout object to a synthetic hook payload (or null to skip).
 // Mutates codexSessionModel and returns { payload, modelEvent } where
 // modelEvent is an optional ModelObserved to emit first when the model changed.
-function codexObjToPayload(obj, sid, cwd) {
+//
+// Exported for the tests: this is the whole of the Codex translation, and the
+// lifecycle it produces is worth pinning against the real reducer without
+// standing up a watcher, a temp home and a 1.5s poll to get at it.
+export function codexObjToPayload(obj, sid, cwd) {
   const type = obj && obj.type;
   const pl = (obj && obj.payload) || {};
   const base = { session_id: sid, cwd, provider: "codex" };
@@ -913,12 +935,49 @@ function codexObjToPayload(obj, sid, cwd) {
       const prompt = typeof pl.message === "string" ? pl.message : "";
       return { ...base, hook_event_name: "UserPromptSubmit", prompt, model };
     }
+    // Codex 0.147 stopped writing `user_message` and writes the same submission
+    // as an `item_completed` carrying a `UserMessage` item instead. The two are
+    // mutually exclusive per CLI version — across the rollouts sampled here the
+    // 0.144 files have `user_message` and no `item_completed` at all, and the
+    // 0.147 files have exactly one `UserMessage` item per turn and no
+    // `user_message` — so handling both names emits one prompt per turn either
+    // way rather than two on either version. The item is the human's typed text
+    // only: the AGENTS.md preamble Codex prepends is written as a bare
+    // `response_item` with role "user" and never gets an item of its own.
+    //
+    // This matters far beyond the prompt text. `UserPromptSubmit` is what puts
+    // a settled root back to `active` (reducer.ts), so on 0.147 it is the ONLY
+    // thing that reopens a session for its second turn — without it the `Stop`
+    // below would trade "live forever" for "done forever", which is not better.
+    if (pl.type === "item_completed" && pl.item && pl.item.type === "UserMessage") {
+      return { ...base, hook_event_name: "UserPromptSubmit", prompt: codexItemText(pl.item), model };
+    }
     if (pl.type === "token_count" && pl.info && pl.info.total_token_usage) {
       return { ...base, hook_event_name: "UsageObserved", usage: pl.info.total_token_usage, model };
     }
     if (pl.type === "task_started" && typeof pl.model_context_window === "number") {
       return { ...base, hook_event_name: "ModelObserved", model, model_context_window: pl.model_context_window };
     }
+    // The end of a turn, which is the only end Codex ever announces. Both names
+    // are one outcome as far as the deck is concerned — the turn is over and
+    // nothing is running — so both settle the root the way Claude's own Stop
+    // hook does. They are also exhaustive: across the rollouts sampled here
+    // every `task_started` is answered by exactly one of the two (54 completes
+    // + 1 abort for 55 starts), so no turn is left open by this mapping and
+    // none is closed twice. `turn_aborted` is the Esc key, and it is the case
+    // that matters most on the deck: pressing Esc is precisely when the user is
+    // watching to confirm the thing stopped.
+    //
+    // Per TURN, not per session, and that is correct: Codex writes no
+    // session-close record at all — a rollout simply stops growing when the
+    // terminal goes away — so `sweepStaleSessions` remains the only thing that
+    // ends a Codex *session*, and it must. What changes is that it now only
+    // ever sees the sessions it was written for: the ones that died without
+    // finishing. A turn that really ended is settled here, at the moment it
+    // ended, with no `reaped` flag, because it was a finish and not a guess.
+    if (pl.type === "task_complete" || pl.type === "turn_aborted") {
+      return { ...base, hook_event_name: "Stop", model };
+    }
     return null;
   }
   if (type === "response_item") {
@@ -1859,6 +1918,37 @@ async function handleSoundHookSet(req, res) {
 // can read before a single event has arrived.
 let _workspace = "";
+/**
+ * The one spelling of `--workspace` everything downstream compares against.
+ * Empty — including a value that is nothing but spaces — stays empty, which is
+ * how every reader of it says "machine-wide".
+ *
+ * Called once, in bin/deck.js, where the flag arrives: that process's cwd is the
+ * shell the user typed the command in, and it is the only process on either
+ * capture path whose cwd is the one a relative `--workspace ./sub` was written
+ * against. The raw string used to go straight into the discovery file, and
+ * hook.js resolved it inside its own process — which the host CLI runs with the
+ * AGENT's cwd — so `--workspace ./sub` scoped Claude sessions to a `sub`
+ * directory under whatever the agent happened to be working in, a different
+ * directory per agent and none of them the one asked for. The Codex path
+ * resolved the same string in the server process and was right. Resolving here
+ * makes both of them right, and for the same reason bin/deck.js already resolves
+ * the events log before publishing it: what goes in the discovery file is read
+ * by other processes that cannot reconstruct the context it was written in.
+ *
+ * Symlinks are resolved too, because a process's cwd — which is what both
+ * providers report — comes from getcwd() and has none left in it. Without this,
+ * `--workspace /tmp/proj` on a Mac is scoped to /tmp/proj while every session
+ * inside it reports /private/tmp/proj, and the deck stays empty. A path that
+ * does not exist yet keeps its resolved form rather than failing: scoping a deck
+ * to a directory you are about to create is not an error.
+ */
+export function canonicalWorkspace(raw) {
+  if (typeof raw !== "string" || raw.trim() === "") return "";
+  const abs = resolve(raw);
+  try { return realpathSync(abs); } catch { return abs; }
+}
 function handleHealth(_req, res) {
   send(res, 200, {
     ok: true,

package/src/server/log-writer.mjs CHANGED Viewed

@@ -73,17 +73,29 @@ export function electWriters(decks, platform = process.platform) {
 /**
  * Would a deck scoped to `workspace` capture a rollout running in `cwd`? An
- * empty workspace is unscoped and captures every session.
+ * empty workspace is unscoped and captures every session; a rollout that never
+ * said where it runs is inside no workspace, so only an unscoped deck draws it.
  *
- * Case is folded on every platform here, which the hook's own cwdInWorkspace
- * deliberately does not do. That stays as it was, because this predicate now
- * answers two questions with one function: whether THIS deck tails a rollout,
- * and whether another deck tails it too. Model the other deck's capture with a
- * rule stricter than the one it actually runs and the election covers the wrong
- * set — a deck that writes without being elected, or an elected deck that never
- * saw the file. Being wrong in the over-matching direction on Linux costs a deck
- * a sibling tree it was not scoped to; being wrong in either direction here
- * costs a duplicated log line or a lost one.
+ * This answers two questions with one function — whether THIS deck tails a
+ * rollout, and whether another deck tails it too — and that is only sound while
+ * the rule below is the rule every deck actually runs. Model another deck's
+ * capture with anything else and the election covers the wrong set: a deck that
+ * writes without being elected, or an elected deck that never opened the file.
+ *
+ * It is also the rule hook/hook.js runs for the sessions it delivers, under the
+ * name capturesSession — that script is copied out of the package and run
+ * standalone, so the two are written twice and pinned equal by a test walking
+ * one table of paths through both. They were not equal: case was folded here on
+ * every platform, so on Linux a deck scoped to /srv/proj captured Codex sessions
+ * from /srv/Proj and Claude sessions from neither. Those are two real
+ * directories there, and the hook's own comment says what folding them together
+ * costs — a deck handed the events of a tree it was not scoped to. So the fold
+ * is per-platform on both sides now, and `--workspace` means one thing.
+ *
+ * (The narrow window that opens: two decks on Linux whose workspaces differ only
+ * in case, one of them old enough to still fold, both containing one rollout's
+ * cwd. Each models the other as tailing the file; one of them is wrong, and the
+ * cost is a single log line written twice.)
  *
  * The platform is a parameter, following the hook's cwdInWorkspace and
  * spawnSpec in src/server/exec.mjs, so the Windows separator is testable from a
@@ -93,8 +105,9 @@ export function codexCwdInWorkspace(cwd, workspace, platform = process.platform)
   if (!workspace || typeof workspace !== "string") return true;
   if (!cwd || typeof cwd !== "string") return false;
   const p = platform === "win32" ? win32 : posix;
-  const a = p.resolve(cwd).toLowerCase();
-  const b = p.resolve(workspace).toLowerCase();
+  const fold = s => (foldsCase(platform) ? s.toLowerCase() : s);
+  const a = fold(p.resolve(cwd));
+  const b = fold(p.resolve(workspace));
   if (a === b) return true;
   // A root ("C:\", "/") already ends in the separator; appending a second one
   // would match nothing.
@@ -106,13 +119,15 @@ export function codexCwdInWorkspace(cwd, workspace, platform = process.platform)
  * it? `decks` is every deck registered right now, `pid` identifies this one
  * among them, and `cwd` is the workspace the rollout is running in.
  *
- * The group is every deck that tails this same rollout — the hook's targets are
- * narrowed to the longest workspace match, but nothing narrows these: each deck
- * decides for itself, so all of them whose workspace contains the cwd read the
- * file and all of them would write it. A deck started with `--no-codex` tails
- * nothing and is left out; electing it would mean the rollout's events reach no
- * log at all. A deck too old to say either way is assumed to be tailing, which
- * is what it was doing before this field existed.
+ * The group is every deck that tails this same rollout: each deck decides for
+ * itself, so all of them whose workspace contains the cwd read the file and all
+ * of them would write it. The hook builds the same group the same way for the
+ * events it delivers — it used to narrow them to the longest workspace match
+ * first, which is the asymmetry the predicate above describes the end of. A deck
+ * started with `--no-codex` tails nothing and is left out; electing it would
+ * mean the rollout's events reach no log at all. A deck too old to say either
+ * way is assumed to be tailing, which is what it was doing before this field
+ * existed.
  */
 export function writesCodexLog({ decks, pid, cwd, platform = process.platform }) {
   const live = Array.isArray(decks) ? decks : [];