agent-dag 1.43.0 → 1.44.1

package/README.md

@@ -180,7 +180,7 @@ What the banner offers depends on how this copy was installed:
 
 | Installed as | Offer |
 |---|---|
-| global npm install | **Update now** — runs `npm install -g agents-deck@latest`, then restarts once nothing is running |
+| global npm install | **Update now** — runs `npm install -g` on the name you installed (`ccdeck`, `agents-deck` or `agent-dag`), then restarts once nothing is running |
 | `npx` | **Update & restart** — re-runs the spec through npx, which fetches a fresh copy and takes over the same port |
 | git checkout | the command, because your working copy leads npm: `git pull && npm run build` |
 | directory not writable | the command — a root-owned prefix is declined up front rather than failing inside npm |
@@ -208,14 +208,18 @@ under three, and `npx` runs the same deck from any of them.
 
 ```bash
 npx ccdeck        # this repo's name — the short one
-npx agents-deck   # the canonical npm package (in-app updates install this one)
+npx agents-deck   # the name it shipped under before the rename
 npx agent-dag     # the original name; existing installs and scripts keep working
 ```
 
-A global install is the one place the three differ. `agents-deck` and
-`agent-dag` are one build published twice, so `npm i -g` on either puts all
-three commands on your `PATH`. `ccdeck` is a thin package that depends on
-`agents-deck` and ships only the `ccdeck` command.
+The three are one build published three times, so they behave identically:
+`npx` on any of them fetches a single package, and `npm i -g` on any of them
+puts all three commands on your `PATH`.
+
+`ccdeck` was the exception until recently — a thin package that depended on
+`agents-deck` and spawned its binary. It worked, but `npx ccdeck` downloaded two
+packages instead of one and a global `ccdeck` ran under the old package's name.
+It is now the same build as the other two.
 
 The repository was previously named `agents-deck`; the old URL redirects here,
 so existing clones, links and bookmarks keep working.

package/bin/agent-dag.js

@@ -31,6 +31,7 @@
 // Everything else the deck does still lives in bin/deck.js. This file must stay
 // boring: it is the one process that is never replaced.
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
 import { connect } from "node:net";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -38,10 +39,10 @@ import { killTree } from "../src/server/exec.mjs";
 import { invokedAs } from "../src/server/invoked-as.mjs";
 import { npxFailureHint, npxFailureSummary, npxLaunch, npxPrefetch } from "../src/server/npx.mjs";
 import {
-  bareSpecName, claimRestartFailureKey, clearRestartFailure, installedVersion, lastKnownLatest,
-  npxRestartSpec, readRestartFailure, recordRestartFailure,
+  bareSpecName, claimRestartFailureKey, clearRestartFailure, installedName, installedVersion,
+  lastKnownLatest, npxRestartSpec, readRestartFailure, recordRestartFailure, successorRoot,
 } from "../src/server/self-update.mjs";
-import { dieOfSignal, upgradeAttempt, upgradeRefusalText, workerExitAction } from "../src/server/supervisor.mjs";
+import { dieOfSignal, replacedNote, upgradeAttempt, upgradeRefusalText, workerExitAction } from "../src/server/supervisor.mjs";
 import { colorProfile, glyphs, palette, unicodeOK } from "../src/server/term.mjs";
 import { PRODUCT } from "../src/server/brand.mjs";
 
@@ -101,6 +102,19 @@ let attempting = null;
 let stopping = false;
 
 function launch(respawn) {
+  // Asked on every spawn rather than once at boot: the deletion this catches
+  // happens while the deck is running, so a constant read at import time would
+  // be the one answer that cannot see it. See supervisor.mjs for the whole case.
+  const replaced = replacedNote({
+    workerExists: existsSync(WORKER),
+    moved: successorRoot(PKG_ROOT),
+    product: PRODUCT,
+    command: INVOKED_AS ?? PRODUCT,
+  });
+  if (replaced) {
+    console.error(replaced);
+    process.exit(1);
+  }
   const args = [WORKER, ...process.argv.slice(2)];
   // Appended last so it wins: the worker's parser keeps the final --port.
   if (respawn && boundPort != null) args.push("--port", String(boundPort));
@@ -188,6 +202,43 @@ function withoutPortAndOpen(args) {
   return out;
 }
 
+/**
+ * Which package an npx upgrade here names, and the spec that installs it — or
+ * null when this deck was not started by npx and there is nothing to re-run.
+ *
+ * One function because there is one answer, and the worker above us reaches it
+ * independently: `upgradeName` in self-update.mjs resolves the npx case as
+ * `bareSpecName(npxRestartSpec(pkgRoot, installedName(pkgRoot)))`, and
+ * everything registry-shaped on that side — the dist-tag it fetched, the marker
+ * it cached the answer in, the failure note the browser reads — is keyed by it.
+ * This supervisor keyed the same four things off `npxRestartSpec(PKG_ROOT)`
+ * with the module's own default, which is the literal string "agents-deck".
+ *
+ * Both read `_npx/<hash>/package.json`, so they agreed for as long as that
+ * metadata was readable, and #340 made the disagreement matter when it is not:
+ * the three names are one tarball now, so the manifest under a `npx ccdeck` run
+ * genuinely says `ccdeck` where it once always said `agents-deck`. A cache
+ * directory written by an npm whose `_npx.packages` layout differs — or a
+ * truncated file — split the two apart: the worker asked npm about `ccdeck` and
+ * read `.restart-failed-ccdeck-<pid>` while this process wrote
+ * `.restart-failed-agents-deck-<pid>`, took `lastKnownLatest("agents-deck")`
+ * off a marker nobody had written — so `target` was null and upgradeAttempt's
+ * per-target cap degraded to "any failure counts" — and relaunched
+ * `npx -y agents-deck@latest`, moving a `npx ccdeck` user onto a different
+ * published name. The note went where the browser never looks, which is the
+ * exact class of bug NOTE_PREFIX's naming exists to prevent.
+ *
+ * So the fallback is the name npm's rename wrote into this build's own manifest,
+ * which is what the worker falls back to as well. Read on each call rather than
+ * once at import for the reason installedVersion gives: the manifest is a file
+ * on disk, and this process outlives more than one of them.
+ */
+function npxUpgrade() {
+  const self = installedName(PKG_ROOT);
+  const spec = npxRestartSpec(PKG_ROOT, self);
+  return spec ? { spec, pkgName: bareSpecName(spec) ?? self } : null;
+}
+
 /** The note the browser reads, written by the only process that knows why an
  *  upgrade did not happen. `failedAt` is when the FETCH failed, which a refusal
  *  restating an earlier failure carries forward — see upgradeAttempt. */
@@ -227,11 +278,11 @@ async function prefetchUpgrade(worker) {
   if (stopping || fetching || attempting) return;
   const reply = (msg) => { try { worker.send?.(msg); } catch { /* the worker is gone */ } };
 
-  const spec = npxRestartSpec(PKG_ROOT);
+  const upgrade = npxUpgrade();
   // Not an npx run after all, so there is nothing to fetch and the files on
   // disk are already the newest this deck can reach.
-  if (!spec) { reply({ type: "upgrade-refused", error: "this deck was not started by npx" }); return; }
-  const pkgName = bareSpecName(spec) ?? "agents-deck";
+  if (!upgrade) { reply({ type: "upgrade-refused", error: "this deck was not started by npx" }); return; }
+  const { spec, pkgName } = upgrade;
   // What the banner offered, straight off the marker the version check writes.
   // The note is keyed by it so that "this exact version already failed here" is
   // a question anything can answer — and so a newer release clears the slate.
@@ -284,8 +335,12 @@ async function prefetchUpgrade(worker) {
  * down), and someone has to bring the working copy back when it does.
  */
 function launchNpx() {
-  const spec = npxRestartSpec(PKG_ROOT);
-  if (!spec) { launch(true); return; } // not an npx run after all
+  const upgrade = npxUpgrade();
+  if (!upgrade) { launch(true); return; } // not an npx run after all
+  // The same package prefetchUpgrade fetched and the worker asked npm about —
+  // one answer, so the spec that is run, the note that records it and the
+  // marker its target came from all name one package. See npxUpgrade.
+  const { spec, pkgName } = upgrade;
   // Our two are appended, so the originals are dropped rather than left to be
   // overridden — `--port 4317 --no-open --port 4317 --no-open` works, but it is
   // what the next person reads in `ps`.
@@ -298,7 +353,6 @@ function launchNpx() {
   // A retry answers for itself: whatever the last attempt left on disk is about
   // to be replaced by this attempt's outcome, and leaving it there would keep
   // the browser showing an old failure over a running fetch.
-  const pkgName = bareSpecName(spec) ?? "agents-deck";
   clearRestartFailure(pkgName);
 
   // No "fetching…" line here any more: prefetchUpgrade printed it and the

package/bin/deck.js

@@ -64,10 +64,31 @@ if (flags.version) {
 
 if (flags.uninstall) {
   const { uninstallHooks, hasCodexInstalled } = await import(pathToFileURL(join(PKG_ROOT, "src/server/installer.mjs")).href);
-  const claude = await uninstallHooks({ provider: "claude" });
-  console.log(claude.changed
-    ? `${PRODUCT}: hooks removed from ${claude.settingsPath}`
-    : `${PRODUCT}: no Claude hooks to remove`);
+  // Anything that could not be taken out. An uninstall that removed nothing
+  // because it could not read the file has not uninstalled anything, and both
+  // the wording and the exit code have to say so: a user who is told it worked
+  // and still has our hooks firing on every event is worse off than one who is
+  // told it failed, because they have stopped looking.
+  let refused = false;
+  // Files already reported as unparseable. The Claude hooks and the sound hook
+  // live in the SAME settings.json, so a stray comma refuses both, and printing
+  // the whole path-plus-parser-error twice buries the one line that differs —
+  // which of our two installations is still in there.
+  const named = new Set();
+  /** Report one provider's outcome. `ok` first — see uninstallHooks. */
+  const report = (res, label) => {
+    if (res.ok === false) {
+      refused = true;
+      named.add(res.settingsPath);
+      console.error(`${PRODUCT}: ${label} hooks NOT removed — ${res.settingsPath} could not be read as JSON (${res.why}).`);
+      console.error(`${PRODUCT}: the __agent-dag hook entries are still in that file and keep firing on every ${label} event.`);
+      return;
+    }
+    console.log(res.changed
+      ? `${PRODUCT}: hooks removed from ${res.settingsPath}`
+      : `${PRODUCT}: no ${label} hooks to remove`);
+  };
+  report(await uninstallHooks({ provider: "claude" }), "Claude");
   // The sound toggle is a second entry in the same file, marked
   // __agent-dag-sound rather than __agent-dag, and uninstallHooks does not know
   // that mark — so it used to be left behind, playing on every turn after the
@@ -77,18 +98,25 @@ if (flags.uninstall) {
   const { uninstallSoundHook } = await import(pathToFileURL(join(PKG_ROOT, "src/server/sound-hook.mjs")).href);
   const sound = await uninstallSoundHook();
   if (sound.ok === false) {
-    console.error(`${PRODUCT}: sound hook left in place — ${sound.message}`);
+    refused = true;
+    console.error(named.has(sound.settingsPath)
+      ? `${PRODUCT}: the sound hook is still in that file too.`
+      : `${PRODUCT}: sound hook left in place — ${sound.message}`);
   } else {
     if (sound.removed) console.log(`${PRODUCT}: sound hook removed`);
     if (sound.restored) console.log(`${PRODUCT}: restored ${sound.restored} of your own sound hook(s)`);
   }
   if (hasCodexInstalled()) {
-    const codex = await uninstallHooks({ provider: "codex" });
-    console.log(codex.changed
-      ? `${PRODUCT}: hooks removed from ${codex.settingsPath}`
-      : `${PRODUCT}: no Codex hooks to remove`);
+    report(await uninstallHooks({ provider: "codex" }), "Codex");
   }
-  process.exit(0);
+  // The remedy last and once, after every symptom above it, rather than once
+  // per refusal in the middle of the list.
+  if (named.size > 0) {
+    console.error(`${PRODUCT}: repair the JSON (or move the file aside), then run \`${PRODUCT} --uninstall\` again.`);
+  }
+  // Non-zero when any half of it refused, so `ccdeck --uninstall && …` and every
+  // CI step that runs this stops on the failure instead of continuing past it.
+  process.exit(refused ? 1 : 0);
 }
 
 const port = Number(flags.port ?? process.env.AGENT_DAG_PORT ?? 4317);