npm - agent-dag - Versions diffs - 3.22.1 → 3.22.4 - Mend

agent-dag 3.22.1 → 3.22.4

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 (70) hide show

package/README.md +6 -477
package/package.json +14 -48
package/shim.js +107 -0
package/LICENSE +0 -661
package/LICENSING.md +0 -82
package/THIRD_PARTY_NOTICES.md +0 -395
package/bin/agent-dag.js +0 -626
package/bin/deck.js +0 -1805
package/dist/web/assets/index-CJYsv0lr.css +0 -1
package/dist/web/assets/index-Ifm23DDC.js +0 -270
package/dist/web/index.html +0 -49
package/hook/hook.js +0 -542
package/release-notes.json +0 -398
package/src/server/activity.mjs +0 -52
package/src/server/agent-activity.mjs +0 -522
package/src/server/args.mjs +0 -183
package/src/server/auto-update.mjs +0 -79
package/src/server/block-notify.mjs +0 -173
package/src/server/boot-deadline.mjs +0 -127
package/src/server/brand.mjs +0 -16
package/src/server/browser-history.mjs +0 -497
package/src/server/browser-presence.mjs +0 -211
package/src/server/browser-profiles.mjs +0 -279
package/src/server/browser-react.mjs +0 -284
package/src/server/browser-watch-store.mjs +0 -350
package/src/server/browser-watch.mjs +0 -905
package/src/server/ccusage.mjs +0 -1168
package/src/server/claude-accounts.mjs +0 -951
package/src/server/claude-dir.mjs +0 -213
package/src/server/codex-auth.mjs +0 -388
package/src/server/codex-dir.mjs +0 -171
package/src/server/codex-quota.mjs +0 -449
package/src/server/codex-usage.mjs +0 -512
package/src/server/cswap-admin.mjs +0 -1562
package/src/server/cswap-auto.mjs +0 -658
package/src/server/cswap-install.mjs +0 -641
package/src/server/deck-home.mjs +0 -243
package/src/server/deck-prefs.mjs +0 -301
package/src/server/deck-probe.mjs +0 -111
package/src/server/detach.mjs +0 -244
package/src/server/exec.mjs +0 -996
package/src/server/global-install.mjs +0 -67
package/src/server/hwmonitor.mjs +0 -56
package/src/server/index.mjs +0 -6043
package/src/server/installer.mjs +0 -912
package/src/server/invoked-as.mjs +0 -144
package/src/server/lan-about.mjs +0 -119
package/src/server/lan-engine.mjs +0 -952
package/src/server/lan-reach.mjs +0 -256
package/src/server/lan-socket.mjs +0 -682
package/src/server/lan-sync.mjs +0 -941
package/src/server/lhm-parse.mjs +0 -91
package/src/server/log-tail.mjs +0 -139
package/src/server/log-writer.mjs +0 -322
package/src/server/login-service.mjs +0 -473
package/src/server/macmon.mjs +0 -310
package/src/server/npx.mjs +0 -264
package/src/server/open-url.mjs +0 -242
package/src/server/presence.mjs +0 -40
package/src/server/quota.mjs +0 -792
package/src/server/relay-guard.mjs +0 -507
package/src/server/reset-label.mjs +0 -78
package/src/server/retire-sound-hook.mjs +0 -349
package/src/server/running-deck.mjs +0 -234
package/src/server/self-update.mjs +0 -1380
package/src/server/stop-deck.mjs +0 -171
package/src/server/supervisor.mjs +0 -392
package/src/server/system-metrics.mjs +0 -1825
package/src/server/term.mjs +0 -686
package/src/server/uv-bootstrap.mjs +0 -337

package/dist/web/index.html DELETED Viewed

@@ -1,49 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>ccdeck</title>
-    <!-- The resting pair, and only the resting pair. Both are parsed before any
-         module runs, so this is the deck at boot — nothing waiting, nothing
-         known to be running — and App.tsx's ambient effect corrects both within
-         the first frame it has state for. The title is the one copy of the name
-         that no constant can reach (display-name.test.ts pins it to PRODUCT);
-         the href is ambient.ts's own idle mark, generated by FAVICON_HREF and
-         pinned to it by ambient-signal.test.ts, which is why it is an
-         unreadable percent-encoded run rather than something to hand-edit. It
-         was a `<text>◉</text>` glyph until #338 — a font-dependent shape that
-         renders at three different weights on the three platforms and as tofu
-         where the codepoint is missing, which stopped being acceptable the
-         moment the icon started carrying state. -->
-    <link rel="icon" href="data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2032%2032%22%3E%3Ccircle%20cx%3D%2216%22%20cy%3D%2216%22%20r%3D%2212%22%20fill%3D%22none%22%20stroke%3D%22%237e828c%22%20stroke-width%3D%225%22%2F%3E%3C%2Fsvg%3E" />
-    <!-- The theme, before the first frame rather than after it.
-         styles.css keys every colour off :root[data-theme=…] and reads a
-         missing attribute as dark, so a light-theme user whose preference is
-         applied by a React effect watches a fully painted dark deck first —
-         native scrollbars and form controls included, because that block also
-         declares color-scheme: dark. The bundle cannot fix this: it is a module
-         script, so it is deferred and the paint can happen while it is still
-         being fetched. This is a classic inline script, which means the parser
-         stops here, inside <head>, before any frame exists — and it is what
-         Vite leaves untouched in the built HTML (it rewrites only scripts with
-         a src or type="module"). Deliberately dependency-free, and kept honest
-         against resolveTheme() in theme.ts by theme-first-paint.test.ts, which
-         runs this exact text. -->
-    <script>
-      (function () {
-        var stored = null;
-        // `window.localStorage` is a GETTER that throws where site data is
-        // blocked, so the property read is inside the try, not just getItem.
-        // A refused store must cost a preference and never the boot.
-        try { stored = window.localStorage.getItem("agent-dag.theme"); } catch (e) {}
-        document.documentElement.setAttribute("data-theme", stored === "light" ? "light" : "dark");
-      })();
-    </script>
-    <script type="module" crossorigin src="/assets/index-Ifm23DDC.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CJYsv0lr.css">
-  </head>
-  <body>
-    <div id="root"></div>
-  </body>
-</html>

package/hook/hook.js DELETED Viewed

@@ -1,542 +0,0 @@
-#!/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 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");
-const path = require("path");
-const http = require("http");
-const os = require("os");
-const crypto = require("crypto");
-// Single shared discovery dir — Claude Code and Codex CLI both register here
-// via the installer. Lets one running agent-dag server receive both providers.
-//
-// This has to name the same directory src/server/claude-dir.mjs does, because
-// the installer writes the files read below. It is duplicated rather than
-// imported because this script is copied out of the package and run standalone
-// by the host CLI, with no path back to the module it came from.
-const configOverride = (process.env.CLAUDE_CONFIG_DIR || "").trim();
-const CLAUDE_DIR = configOverride
-  ? path.resolve(configOverride)
-  : path.join(os.homedir(), ".claude");
-const DIR = path.join(CLAUDE_DIR, "agent-dag");
-function parseProvider(argv) {
-  for (let i = 0; i < argv.length; i++) {
-    if (argv[i] === "--provider" && i + 1 < argv.length) return argv[i + 1];
-  }
-  return "claude";
-}
-const PROVIDER = parseProvider(process.argv.slice(2));
-/**
- * The one spelling of a directory, so that a path this process reports and a
- * path bin/deck.js published can be compared as strings.
- *
- * Resolving symlinks is the half that is easy to think you can skip, because on
- * POSIX a cwd comes from getcwd(3) and has none left in it. Windows has no such
- * guarantee — GetCurrentDirectoryW returns the string the directory was set
- * with, junction, `subst` drive and all — so a workspace reached that way only
- * matches if BOTH sides go through here. The server's rollout watcher keeps its
- * own copy of this rule under the name canonicalCwd, for the Codex sessions that
- * never reach this file; a test walks one path through both. A path that does
- * not resolve keeps its resolved form, which is also what canonicalWorkspace
- * does with a directory the user has not created yet.
- *
- * `.native` IS THE RULE, not a detail. fs.realpathSync is a JavaScript
- * lstat-and-readlink walk that resolves symlinks and junctions and nothing else;
- * fs.realpathSync.native is GetFinalPathNameByHandleW, which also expands a DOS
- * 8.3 short component to its long form. This used to call the plain one while
- * the server's canonicalCwd went through the native one, so the moment a path
- * arrived short — `%TEMP%` under a shortened profile directory, which is what
- * every GitHub Windows runner has — the two canonicalisers that exist to agree
- * disagreed by a whole path: C:\Users\RUNNER~1\… against C:\Users\runneradmin\….
- * canonicalWorkspace in src/server/index.mjs says the rest of it, including why
- * the long form is the canonical one; all three sites name `.native` out loud.
- *
- * Exported for that test: it is half of what `--workspace` means, and a
- * predicate handed an already-canonical path cannot show that the caller
- * canonicalises.
- */
-function normPath(p) {
-  let r = path.resolve(p);
-  try { r = fs.realpathSync.native(r); } catch {}
-  return r;
-}
-/**
- * Does this platform's filesystem treat two spellings that differ only in case
- * as the same directory? Exported for tests: the platform is a parameter so
- * both answers can be checked from either kind of machine.
- *
- * Windows always does, and macOS does by default (APFS and HFS+ are formatted
- * case-insensitive unless the user deliberately chose otherwise). Linux does
- * not, and folding case there would be a bug of its own: /srv/Proj and
- * /srv/proj are two real directories, and a deck scoped to one must not be
- * handed the other's events.
- *
- * A case-sensitive macOS volume is therefore over-matched. That is the safe
- * direction to be wrong in — the cost is a deck that also sees a sibling tree
- * it was not scoped to, against the cost of the default configuration seeing
- * nothing at all.
- */
-const foldsCase = (platform = process.platform) =>
-  platform === "win32" || platform === "darwin";
-/**
- * Is `cwd` the workspace directory or somewhere inside it?
- *
- * Both sides arrive already resolved, but resolved is not the same as
- * comparable. Neither path.resolve nor the JS fs.realpathSync canonicalizes
- * character case, so the drive letter and every component keep whatever case
- * the process that reported them happened to use — `c:\proj` from one shell,
- * `C:\Proj` from another, for one directory. A raw === / startsWith then says
- * "not in the workspace", the hook posts to nobody, and a scoped deck stays
- * empty with no error printed anywhere. Re-resolving through the platform's
- * own path flavour also settles separators and a trailing one, so
- * `C:/proj/` and `C:\proj` compare equal too.
- *
- * The platform is a parameter, following spawnSpec/isBatch in
- * src/server/exec.mjs, so the Windows rule is testable from a POSIX machine.
- */
-function cwdInWorkspace(cwd, workspace, platform = process.platform) {
-  const p = platform === "win32" ? path.win32 : path.posix;
-  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.
-  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);
-}
-// Signal 0 delivers nothing; it asks whether the pid could be signalled.
-//
-// BOTH ERRNOS, and the second one is the Windows spelling. POSIX `kill(2)`
-// answers EPERM for a process this account may not signal. On Windows
-// `uv_kill` calls `OpenProcess`, a denial is ERROR_ACCESS_DENIED, and libuv
-// maps that to EACCES — so a deck started from an elevated terminal, or under
-// another account, read as DEAD to every probe in this repo. What followed was
-// silent: the live deck's discovery file was unlinked on the next hook fire,
-// rewritten five seconds later by keepDiscovery, and its banner went on
-// claiming it was receiving events it had stopped receiving.
-function isAlive(pid) {
-  try { process.kill(pid, 0); return true; }
-  catch (e) { return !!e && (e.code === "EPERM" || e.code === "EACCES"); }
-}
-/**
- * Of the decks about to be posted this event, which ones should also write it
- * to disk? Returns the subset that should; every other target is asked to
- * display the event and keep no record of it.
- *
- * The fan-out itself is deliberate — several decks can match one session and
- * they should all draw it. Persisting is not: they all default to the same
- * <claude config dir>/agent-dag/events.jsonl, so each of them appending its own
- * copy wrote every event once per running deck. The file then grew N times as
- * fast, rotated N times as often, and every replay of it ingested each tool
- * call N times, which is what put duplicate tools and duplicate bubbles on the
- * canvas after a restart.
- *
- * Decks are therefore grouped by the log file each one names in its discovery
- * record, and one deck per group is elected. Grouping by the file rather than
- * counting decks is what keeps the overrides honest: a deck run with
- * `--history` sits alone in its own group and always writes, a deck run with
- * `--no-persist` reports no file and can never be elected to write for one that
- * does, and a deck too old to report either keeps the behaviour it had before
- * this rule existed. Within a group the lowest port wins — a fixed rule, so the
- * same deck holds the file for as long as it is up and the next one inherits it
- * as soon as that deck is gone.
- *
- * The platform is a parameter, like cwdInWorkspace's, so the case-folding half
- * is testable from any machine.
- *
- * src/server/log-writer.mjs repeats this rule for the events no hook delivers —
- * the ones the server builds itself from Codex's rollout files — because this
- * script is copied out of the package and cannot import it. A test compares the
- * two directly: they decide for the same decks, and a disagreement is a line
- * written twice or not at all.
- */
-function electWriters(decks, platform = process.platform) {
-  const byLog = new Map();
-  for (const d of decks) {
-    const log = typeof d.persist === "string" ? d.persist : "";
-    // Two namespaces, so a deck with no log to share — and a deck too old to
-    // report one — is alone in its group and cannot collide with a real path.
-    const key = log
-      ? `log:${foldsCase(platform) ? log.toLowerCase() : log}`
-      : `deck:${d.pid}:${d.port}`;
-    const held = byLog.get(key);
-    // Ports are unique among live decks; pid only breaks a tie a stale
-    // discovery file could invent, so the answer stays deterministic.
-    if (!held || d.port < held.port || (d.port === held.port && d.pid < held.pid)) {
-      byLog.set(key, d);
-    }
-  }
-  return new Set(byLog.values());
-}
-/**
- * The answer a deck must give to be handed a session payload.
- *
- * Liveness of the recorded pid is not evidence that the thing listening on the
- * recorded port is a deck. A deck killed with SIGKILL or lost to a power cut
- * leaves its discovery file behind — nothing unlinks it — and every cleanup
- * path here and in the server probes the same pid. Once the OS hands that
- * number to some other long-lived process the file passes forever, and the
- * port it names may by then belong to anything at all (4317, the deck's own
- * default, is also the standard OTLP collector port). What was POSTed there is
- * the whole hook event: prompt text, tool inputs, tool results, cwd.
- *
- * So the port has to prove itself before it is told anything. The deck writes a
- * fresh random token into its discovery file at startup; this hook asks the
- * listener to hash that token against a nonce it has never seen, and sends the
- * payload only if the answer matches. A stranger on the port cannot answer
- * without the token, and the nonce is new every time, so an answer overheard
- * earlier is worth nothing. Note the direction: the hook never transmits the
- * token itself, only a challenge, so a wrong listener learns nothing it could
- * replay against the next event.
- *
- * Both sides must derive the proof identically — src/server/index.mjs exports
- * the same function under the same name, and the pair is pinned by a test.
- */
-function challengeProof(token, nonce) {
-  return crypto.createHash("sha256").update(`${token}:${nonce}`).digest("hex");
-}
-/**
- * Must this target answer the challenge before it is handed a payload?
- *
- * Only a deck that advertises a token can be asked to prove it holds one. And
- * hook.js is a single shared file — <claude config dir>/agent-dag/hook.js,
- * installed by whichever deck booted most recently — while running several
- * decks at once is ordinary use. So a hook that knows about the handshake
- * routinely reads discovery files written by decks that predate it, which serve
- * no /api/hook-challenge route at all. Refusing those outright leaves every one
- * of them listening and permanently empty, with its banner still saying it is
- * receiving events.
- *
- * THE FALLBACK IS GONE, on the condition this comment set for itself: "drop it
- * once no deck older than 1.33.71 is plausibly still running". That release is
- * two majors back — this package is on 3.x — so the window has closed.
- *
- * What it did while it stood: a tokenless discovery file was handed the payload
- * on pid liveness alone, which is a control an adversary switches off by
- * leaving a key out of a JSON file. It cost that adversary nothing to write
- * one, since writing into the discovery directory at all is the capability in
- * question — but a stale file from an old deck, or a port another program has
- * since taken, is the ordinary case it also covered, and both are better served
- * by refusing.
- *
- * The cost of refusing is stated plainly: a deck older than 1.33.71 running
- * beside a current one receives nothing, while its banner still says it is
- * connected. That was the reason to keep the fallback in the first place, and
- * it is now a machine nobody has.
- */
-function requiresProof(d) {
-  return true;
-}
-// Constant-time compare, purely so a hostile listener cannot walk the expected
-// proof out of us one byte at a time by timing how long we take to hang up. The
-// lengths are public (64 hex chars) and a mismatched one is rejected outright,
-// which is what timingSafeEqual requires of its arguments anyway.
-function sameProof(got, want) {
-  if (typeof got !== "string") return false;
-  const a = Buffer.from(got, "utf8");
-  const b = Buffer.from(want, "utf8");
-  return a.length === b.length && crypto.timingSafeEqual(a, b);
-}
-// Two round trips happen per target, and main()'s hard cap is 1500ms, so the
-// pair has to fit inside it with room to spare. The challenge is a bodyless GET
-// to a loopback port — sub-millisecond when a deck is there, and instant
-// ECONNREFUSED when nothing is.
-//
-// They are now separated by a barrier: every target is challenged, then the
-// election is decided, then the payload goes out (#695). The worst case is
-// unchanged — the challenges run in parallel, so it is still one 400ms deadline
-// followed by one 1000ms deadline. What the barrier does cost is that an honest
-// deck's POST waits for the slowest challenge in the set, which only matters
-// when some OTHER record's port accepts a connection and then says nothing. A
-// ghost port with nothing behind it refuses instantly and delays no one.
-const CHALLENGE_TIMEOUT_MS = 400;
-const POST_TIMEOUT_MS = 1000;
-/**
- * Ask the listener to prove it is the deck that wrote `d`. `cb` is called
- * exactly once with true or false — a refused connection, a silent port and a
- * wrong answer are all just "not the deck this record describes".
- *
- * A deck that advertised no token cannot be asked and passes: see requiresProof.
- */
-function prove(d, cb, attempt = 0) {
-  let settled = false;
-  // A DEADLINE IS NOT AN ANSWER, and the difference is worth one retry.
-  //
-  // A wrong proof, a refused connection and a 404 are all verdicts: that port
-  // is not the deck this record describes, and asking again would get the same
-  // answer. A TIMEOUT is not — it is a machine too busy to reply in 400ms, and
-  // the deck on the other side is fine. Measured on the Windows box: the full
-  // test suite (335 files in parallel) is enough load to make a healthy deck
-  // miss that window, and the event is then dropped with nothing on screen to
-  // say so. A big build or a machine running several agents is the same shape.
-  //
-  // One retry, only on the deadline, and the budget still fits: 400 + 400 for
-  // the challenge and 1000 for the POST, under the 1900ms cap main() sets —
-  // which is itself under the two-second timeout the installed hook entry
-  // carries, so Claude Code never has to kill this process.
-  const retryOnTimeout = () => {
-    if (settled) return;
-    if (attempt >= 1) return finish(false);
-    settled = true;                        // this attempt is over; the next owns `cb`
-    prove(d, cb, attempt + 1);
-  };
-  const finish = ok => { if (settled) return; settled = true; cb(ok); };
-  if (!requiresProof(d)) return finish(true);
-  const nonce = crypto.randomBytes(16).toString("hex");
-  const want = challengeProof(d.token, nonce);
-  const req = http.request({
-    hostname: "127.0.0.1",
-    port: d.port,
-    path: `/api/hook-challenge?nonce=${nonce}`,
-    method: "GET",
-    timeout: CHALLENGE_TIMEOUT_MS,
-  }, res => {
-    if (res.statusCode !== 200) { res.resume(); return res.on("end", () => finish(false)); }
-    let answer = "";
-    res.setEncoding("utf8");
-    res.on("data", c => {
-      answer += c;
-      // A deck answers in ~100 bytes. Anything pouring data at us is not one,
-      // and must not be allowed to grow this buffer without bound.
-      if (answer.length > 4096) { req.destroy(); finish(false); }
-    });
-    res.on("end", () => {
-      // Already given up on this target — a flood we cut off above. Whatever
-      // arrived before that is not an answer we are going to act on.
-      if (settled) return;
-      let proof;
-      try { proof = JSON.parse(answer).proof; } catch { return finish(false); }
-      finish(sameProof(proof, want));
-    });
-  });
-  // `destroy()` on a timeout makes 'error' fire with ECONNRESET, so the two
-  // handlers have to agree on which of them is speaking: `timedOut` is what
-  // tells a deadline apart from a refusal.
-  let timedOut = false;
-  req.on("error", () => { if (timedOut) retryOnTimeout(); else finish(false); });
-  req.on("timeout", () => { timedOut = true; req.destroy(); });
-  req.end();
-}
-/**
- * Challenge every target, then hand back the ones that answered — in the order
- * they were given, so the election below is a function of the records alone.
- *
- * WHY THIS RUNS BEFORE THE ELECTION AND NOT AFTER IT (#695). The two round trips
- * per target have always both happened; they used to happen in the wrong order.
- * electWriters ran over every record whose pid was merely alive, and only then
- * did deliver() challenge each target and drop the ones that could not answer.
- * So a record left behind by a deck that is gone — SIGKILL, an OOM kill, a power
- * cut, a console window closed on Windows, none of which run the shutdown that
- * unlinks it — kept passing the one staleness test there is the moment the OS
- * handed its pid to some other long-lived process. If it also named a port below
- * every real deck's, it WON the election, was never posted to because it could
- * not answer, and no other deck was posted to with the flag either: every deck
- * drew the event, all of them were told `?persist=0`, and events.jsonl stopped
- * growing. Silently, for as long as that file sat in the directory.
- *
- * The election has to be decided over the decks that are actually going to be
- * handed the payload, and the only thing that establishes that is the handshake.
- * So: prove, then elect, then post. It costs no extra round trip, only this
- * ordering, and it is the same reordering src/server/index.mjs makes in
- * readLiveDecks for the Codex rollouts no hook ever sees.
- *
- * The record is NOT unlinked when a target fails. A dead pid is proof the deck
- * is gone and is swept above; a failed challenge is not — a deck restarting
- * under its supervisor refuses connections for a moment while its record still
- * stands, and a merely busy one can miss the 400ms deadline. Deleting another
- * deck's registration on that evidence trades a bug that loses log lines for one
- * that loses a whole deck's events, and it buys nothing now that the election no
- * longer believes the record: a ghost that survives on disk costs one instant
- * ECONNREFUSED per hook run and decides nothing.
- */
-function proveTargets(targets, cb) {
-  const ok = new Array(targets.length).fill(false);
-  let pending = targets.length;
-  const settle = () => { if (--pending <= 0) cb(targets.filter((_, i) => ok[i])); };
-  targets.forEach((d, i) => prove(d, answered => { ok[i] = answered; settle(); }));
-}
-/**
- * Hand this deck the payload. `done` runs exactly once, whatever the outcome —
- * a delivered event, a refused connection and a socket that errors after the
- * response are all just "this target is finished".
- *
- * `persists` is this deck's answer from electWriters: true for the one deck that
- * logs the event, false for every other one it is also drawn on.
- */
-function post(d, body, persists, done) {
-  let settled = false;
-  const finish = () => { if (settled) return; settled = true; done(); };
-  const req = http.request({
-    hostname: "127.0.0.1",
-    port: d.port,
-    // Only the elected deck records the event; the rest are asked to draw it
-    // and keep no copy, so one log file ends up with one copy of it.
-    path: persists ? "/api/event" : "/api/event?persist=0",
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    timeout: POST_TIMEOUT_MS,
-  }, res => { res.resume(); res.on("end", finish); });
-  req.on("error", finish);
-  req.on("timeout", () => req.destroy());
-  req.write(body);
-  req.end();
-}
-function main() {
-  // Hard cap so a stuck server can never wedge the host CLI. 1900ms, which is
-  // the challenge's two attempts (400 + 400) plus the POST's 1000 with a little
-  // room — and still under the two-second timeout the installed hook entry
-  // carries, so this process ends itself rather than being killed.
-  setTimeout(() => process.exit(0), 1900);
-  // The deck reads the Claude quota by running `claude --print /usage`, which is
-  // a full Claude Code invocation and therefore fires these hooks. Reporting it
-  // drew a session onto the canvas for every quota poll — no prompt, no tools,
-  // a few seconds long — so the deck filled up with its own measurements. The
-  // probe sets this in the environment and hooks inherit it.
-  if (process.env.AGENTS_DECK_INTERNAL === "1") process.exit(0);
-  let input = "";
-  process.stdin.setEncoding("utf8");
-  process.stdin.on("data", c => { input += c; });
-  process.stdin.on("end", () => {
-    let parsed;
-    try { parsed = JSON.parse(input); } catch { return process.exit(0); }
-    const cwd = parsed && parsed.cwd;
-    if (!cwd) return process.exit(0);
-    // Stamp provider so the server / reducer can branch on it without
-    // re-sniffing payload shape.
-    if (parsed && typeof parsed === "object" && !parsed.provider) {
-      parsed.provider = PROVIDER;
-    }
-    const taggedInput = JSON.stringify(parsed);
-    const resolvedCwd = normPath(cwd);
-    let files;
-    try {
-      files = fs.readdirSync(DIR).filter(f => f.endsWith(".json"));
-    } catch { return process.exit(0); }
-    if (!files.length) return process.exit(0);
-    // 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; }
-      if (typeof d.workspace !== "string" || !d.pid || !d.port) continue;
-      // A missing token is not a reason to drop the file here — prove() decides
-      // what a target has to prove, and a deck older than the handshake can
-      // prove nothing. See requiresProof.
-      if (!isAlive(d.pid)) {
-        try { fs.unlinkSync(path.join(DIR, file)); } catch {}
-        continue;
-      }
-      // "" 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 (!targets.length) return process.exit(0);
-    // Prove, elect, post — in that order, and see proveTargets for what the
-    // other order cost. A record whose pid is merely alive has established
-    // nothing: it may be a deck that died and had its pid recycled, and electing
-    // one of those to write the log meant nobody wrote it (#695).
-    proveTargets(targets, proven => {
-      if (!proven.length) return process.exit(0);
-      // One deck per events log records this event; the others only draw it.
-      const writers = electWriters(proven);
-      let pending = proven.length;
-      const done = () => { if (--pending <= 0) process.exit(0); };
-      for (const d of proven) post(d, taggedInput, writers.has(d), done);
-    });
-  });
-}
-// The host CLI always runs this file as the process entry point — the command
-// the installer writes is `"<node>" "<...>/hook.js" --provider <name>`. Under a
-// 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 = { capturesSession, cwdInWorkspace, foldsCase, normPath, electWriters, challengeProof, requiresProof };
-if (require.main === module) main();