agent-dag 1.33.55 → 1.33.57

package/dist/web/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>agents-deck</title>
     <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Ctext y='84' font-size='84'%3E%E2%97%89%3C/text%3E%3C/svg%3E" />
-    <script type="module" crossorigin src="/assets/index-DRBr38dw.js"></script>
+    <script type="module" crossorigin src="/assets/index-BMwi5hcI.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CF2yG9oG.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.33.55",
+  "version": "1.33.57",
   "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/exec.mjs

@@ -126,8 +126,23 @@ export const tryNext = (err) =>
   Boolean(err) && (err.code === "ENOENT" || err.code === "EACCES" ||
                    err.code === "EINVAL" || err.code === "UNKNOWN");
 
+// The three lines cmd.exe prints when it cannot find what it was asked to run,
+// anchored to a whole line each. First the two-line pair for a bare name, then
+// the one it uses when a directory in an explicit path does not exist.
+const CMD_UNKNOWN = /^'(.+)' is not recognized as an internal or external command,?$/i;
+const CMD_UNKNOWN_TAIL = /^operable program or batch file\.?$/i;
+const CMD_NO_PATH = /^the system cannot find the (?:path|file) specified\.?$/i;
+
+// cmd.exe echoes the command token exactly as it was given, so an exact match
+// is what we expect; the comparison is only case- and quote-insensitive because
+// Windows paths are.
+const sameCommand = (quoted, name) => {
+  const norm = (s) => String(s).trim().replace(/^"+|"+$/g, "").toLowerCase();
+  return norm(quoted) === norm(name);
+};
+
 /**
- * cmd.exe's way of saying ENOENT.
+ * cmd.exe's way of saying ENOENT — and only cmd.exe's.
  *
  * A .cmd or .bat candidate is launched THROUGH cmd.exe, and cmd.exe exists — so
  * a missing tool is not a spawn error at all. It is a healthy shell exiting 1
@@ -140,11 +155,39 @@ export const tryNext = (err) =>
  * second line — on its own, meaningless — in front of the user. Reported from
  * Windows on 2026-08-14: the accounts panel said only "operable program or
  * batch file." when sharing an account.
+ *
+ * The fussiness is about the other direction, which is worse. "The system
+ * cannot find the file specified" is Windows' generic text for ENOENT, and it
+ * appears INSIDE the output of tools that ran perfectly well — cswap is a
+ * Python CLI, and a FileNotFoundError traceback ends in that exact sentence.
+ * Believed there, it threw the real error away, told the user the tool was not
+ * on PATH when PATH was fine, and — the dangerous half — sent the candidate
+ * loop on to re-run the entire command, which for `cswap remove 3` means asking
+ * to delete an account a second time.
+ *
+ * So the output has to be cmd.exe's message and nothing else: cmd.exe prints it
+ * INSTEAD of running anything, so any other line, or any prefix on the line,
+ * means something ran and this is its report. And when cmd.exe names the
+ * command it could not find, that name must be the candidate we asked for — a
+ * tool that shells out itself can forward the message about some other command.
+ *
+ * `name` is the candidate spelling that produced the output. Callers that only
+ * have the text (failureText) omit it and get the shape rules alone.
  */
-export const looksMissing = (text) =>
-  /is not recognized as an internal or external command/i.test(String(text ?? "")) ||
-  /operable program or batch file/i.test(String(text ?? "")) ||
-  /The system cannot find the (?:path|file) specified/i.test(String(text ?? ""));
+export function looksMissing(text, name = "") {
+  const lines = String(text ?? "").split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+  if (!lines.length) return false;
+  for (const line of lines) {
+    const named = CMD_UNKNOWN.exec(line);
+    if (named) {
+      if (name && !sameCommand(named[1], name)) return false;
+      continue;
+    }
+    if (CMD_UNKNOWN_TAIL.test(line) || CMD_NO_PATH.test(line)) continue;
+    return false;
+  }
+  return true;
+}
 
 /**
  * Run a command and collect its output. Never rejects, and never throws —
@@ -175,8 +218,12 @@ export function run(cmd, args, { timeout = 20_000, maxBuffer = 4 << 20 } = {}) {
       const done = (err, stdout, stderr) => {
         clearTimeout(timer);
         // cmd.exe's "is not recognized" counts as "not this spelling" too, and
-        // it arrives as a normal non-zero exit rather than a spawn error.
-        const missing = Boolean(err) && looksMissing(`${stderr ?? ""}\n${stdout ?? ""}`);
+        // it arrives as a normal non-zero exit rather than a spawn error. Only
+        // a batch candidate goes through a shell, so only there can the output
+        // be a shell's verdict rather than the tool's own words — spawned
+        // directly, a missing file is a plain ENOENT and anything printed came
+        // from a tool that ran.
+        const missing = Boolean(err) && tree && looksMissing(`${stderr ?? ""}\n${stdout ?? ""}`, raw);
         if (err && (tryNext(err) || missing) && i + 1 < tries.length) return attempt(i + 1);
         if (!err) resolved.set(cmd, raw);
         resolve({
@@ -317,8 +364,11 @@ export function runInteractive(cmd, args, { timeout = 300_000, maxOutput = 256 <
     proc.on("close", (code) => {
       if (stale()) return;
       // Same cmd.exe case as in `run`: exit 1 with "is not recognized" means
-      // this spelling does not exist, not that the tool failed.
-      if (code !== 0 && looksMissing(`${stderr}\n${stdout}`)) {
+      // this spelling does not exist, not that the tool failed. Restricted to a
+      // batch candidate, which is the only kind launched through a shell, and
+      // to output that is cmd.exe's message alone — everything below re-runs
+      // the whole command, and these commands remove accounts.
+      if (code !== 0 && isBatch(raw) && looksMissing(`${stderr}\n${stdout}`, raw)) {
         if (i + 1 < tries.length) {
           stdout = ""; stderr = ""; pending = "";
           child = null;

package/src/server/self-update.mjs

@@ -458,24 +458,54 @@ export function startUpgrade({ pkgRoot, name = "agents-deck" }) {
   child.stdout.on("data", d => keepTail(String(d)));
   child.stderr.on("data", d => keepTail(String(d)));
 
+  // The deadline states the outcome itself, and only then kills.
+  //
   // npm is a .cmd shim on Windows and is therefore spawned through a shell, so
   // `child` is cmd.exe and npm itself is a grandchild — a plain kill would
-  // report the install as timed out while it carried on writing to node_modules.
-  const timer = setTimeout(() => killTree(child), INSTALL_TIMEOUT_MS);
+  // report the install as timed out while it carried on writing to
+  // node_modules. killTree is what reaches it (taskkill /T there, the same
+  // plain signal everywhere else).
+  //
+  // Leaving the verdict to 'close' was the other half of the same bug. 'close'
+  // waits for the stdio pipes, which the grandchild inherited, so on Windows it
+  // could arrive minutes after the deadline — or never, if the tree kill could
+  // not run at all — and until it did, /api/version kept reporting
+  // `state: "running"` with the UI spinning on "installing…" and the guard at
+  // the top of this function refusing every retry. When it finally arrived it
+  // carried the killed wrapper's status, so a five-minute timeout was announced
+  // to the user as "npm exited null".
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    _upgrade = {
+      state: "failed",
+      command,
+      error: `timed out after ${Math.round(INSTALL_TIMEOUT_MS / 60_000)} minutes`,
+      at: Date.now(),
+    };
+    killTree(child);
+  }, INSTALL_TIMEOUT_MS);
   timer.unref?.();
 
   child.on("error", (e) => {
     clearTimeout(timer);
+    // A kill can make the child emit one of these; whatever it says, the reason
+    // this install failed is the deadline that has already been reported.
+    if (timedOut) return;
     _upgrade = { state: "failed", command, error: e?.message ?? String(e), at: Date.now() };
   });
   child.on("close", (code) => {
     clearTimeout(timer);
     if (code === 0) {
+      // A clean exit is a real install even if it lands after the deadline —
+      // npm finishing in the same breath as the timer is the one case where the
+      // files on disk disagree with the verdict above, and the files win.
+      //
       // Deliberately does not restart anything. The new files on disk make
       // installedVersion() disagree with the running one, and the ordinary
       // drift path takes it from there — including its wait for an idle moment.
       _upgrade = { state: "done", command, error: null, at: Date.now() };
-    } else {
+    } else if (!timedOut) {
       _upgrade = { state: "failed", command, error: lastMeaningfulLine(err) || `npm exited ${code}`, at: Date.now() };
     }
   });