npm - agent-dag - Versions diffs - 1.33.47 → 1.33.49 - Mend

agent-dag 1.33.47 → 1.33.49

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

package/dist/web/assets/{index-Cyd_2XUH.js → index-DXPYK_Sr.js} +1 -1
package/dist/web/index.html +1 -1
package/package.json +1 -1
package/src/server/ccusage.mjs +4 -2
package/src/server/cswap-admin.mjs +34 -10
package/src/server/exec.mjs +62 -4
package/src/server/self-update.mjs +5 -1

package/dist/web/index.html CHANGED Viewed

@@ -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-Cyd_2XUH.js"></script>
+    <script type="module" crossorigin src="/assets/index-DXPYK_Sr.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CF2yG9oG.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.33.47",
+  "version": "1.33.49",
   "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/ccusage.mjs CHANGED Viewed

@@ -15,7 +15,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { spawnSpec } from "./exec.mjs";
+import { killTree, spawnSpec } from "./exec.mjs";
 const CACHE_MS = 120_000; // 2 min — modal is manual-open; cheap to keep warm
 const TIMEOUT_MS = 90_000;
@@ -188,7 +188,9 @@ async function runCcusage(args) {
     });
     let out = "", err = "";
     const timer = setTimeout(() => {
-      child.kill();
+      // The npx fallback runs through a shell, so on Windows `child` is cmd.exe
+      // and npx is a grandchild that a plain kill would leave downloading.
+      killTree(child);
       reject(new Error("ccusage timed out"));
     }, TIMEOUT_MS);
     child.stdout.on("data", d => { out += d; });

package/src/server/cswap-admin.mjs CHANGED Viewed

@@ -158,7 +158,27 @@ export function extractLoginUrl(text) {
 // The prompt the CLI blocks on. Matched rather than assumed: writing a code
 // into a child that is not asking for one would send it somewhere unknown.
-const CODE_PROMPT = /paste code here/i;
+const CODE_PROMPT = /paste code here/gi;
+/**
+ * How many times one line of output asks for the code.
+ *
+ * Per LINE, not per delivery. The prompt ends without a newline, so exec.mjs
+ * re-offers the same unterminated line on every chunk as it grows — and both
+ * streams share that buffer, so a progress dot, a `\r` spinner frame on stderr,
+ * or simply the prompt split across two writes all arrive as the ask again,
+ * a few characters longer. Counting an ask whenever the text merely CHANGED, as
+ * this used to, turned any of those into a phantom second prompt, and a second
+ * prompt is exactly how submitLoginCode hears "that code was rejected": a
+ * login the CLI was busy completing came back as `code_rejected`, with the
+ * account unregistered and the live credentials left switched.
+ *
+ * A real re-ask writes the prompt again — on a fresh line, or after a `\r`
+ * redraw of this one — so it shows up as another match, not as a longer tail.
+ */
+export function countCodePrompts(line) {
+  return (stripTerminalEscapes(line).match(CODE_PROMPT) ?? []).length;
+}
 /**
  * The whole login, as one object, because the browser talks to it twice: once
@@ -219,23 +239,27 @@ export async function startLogin({ email } = {}) {
     // exit, it just asks again, so waiting for exit would hang for the whole
     // five-minute window on a typo.
     prompts: 0,
-    lastPromptText: "",
   };
   const flow = _login;
-  child.onLine((line) => {
+  // How many asks the line currently being written has already contributed.
+  // The prompt is an unterminated line, re-delivered as it grows, so the same
+  // ask arrives over and over — and once more, whole, when something else
+  // finally ends the line.
+  let countedOnLine = 0;
+  child.onLine((line, partial) => {
     if (!flow.url) {
       const url = extractLoginUrl(line);
       if (url) { flow.url = url; flow.state = "awaiting_code"; }
     }
-    // The prompt is an unterminated line, re-delivered as it grows, so the
-    // same ask must not count twice.
-    const clean = stripTerminalEscapes(line);
-    if (CODE_PROMPT.test(clean)) {
-      if (clean !== flow.lastPromptText) { flow.prompts += 1; flow.lastPromptText = clean; }
-    } else if (clean.trim()) {
-      flow.lastPromptText = "";
+    const asks = countCodePrompts(line);
+    if (asks > countedOnLine) {
+      flow.prompts += asks - countedOnLine;
+      countedOnLine = asks;
     }
+    // A newline ended that line; whatever comes next is a new one.
+    if (!partial) countedOnLine = 0;
   });
   // The child dying before the code was accepted is a failure of the login, not
   // of the deck; say so rather than leaving the dialog spinning.

package/src/server/exec.mjs CHANGED Viewed

@@ -78,6 +78,47 @@ export function viaCmd(file, args) {
 export const spawnSpec = (file, args, platform = process.platform) =>
   isBatch(file, platform) ? viaCmd(file, args) : { file, args, opts: {} };
+/**
+ * Stop a child AND everything it started.
+ *
+ * On POSIX the child is the tool, so a signal to it is the whole job and this
+ * is exactly the `child.kill()` it replaces. On Windows a .cmd or .bat runs
+ * THROUGH cmd.exe (see viaCmd), so the tool — node, for the claude and npm
+ * shims — is a grandchild, and a kill is one TerminateProcess against the
+ * wrapper. Windows terminates no descendants and libuv's job object lets them
+ * break away, so the wrapper vanished and the work carried on: every cancelled
+ * or expired `claude auth login` left a node.exe blocked forever on the stdin
+ * pipe this process holds, and because that node.exe kept the inherited stdout
+ * handle open, the wrapper's 'close' never arrived either — the run that was
+ * reported dead never settled.
+ *
+ * `taskkill /T` is the descendant walk Windows does have, and `/F` is what
+ * stops a console app that is not pumping its message queue. Taking it from
+ * System32 rather than from PATH matters here: PATH is the user's, and this is
+ * the program we hand a pid to kill. If it cannot run at all, the plain kill
+ * still happens, which is no worse than before.
+ *
+ * A process group would be the tidier answer and is the wrong one on Windows:
+ * `detached` there only means CREATE_NEW_PROCESS_GROUP, and Node cannot signal
+ * a group — `process.kill(-pid)` is POSIX-only.
+ */
+export function killTree(child, signal) {
+  const plain = () => { try { child?.kill(signal); } catch { /* already gone */ } };
+  if (process.platform !== "win32" || !child?.pid) return plain();
+  try {
+    const root = process.env.SystemRoot || process.env.systemroot;
+    const exe = root ? `${root}\\System32\\taskkill.exe` : "taskkill";
+    const killer = spawn(exe, ["/pid", String(child.pid), "/T", "/F"], {
+      stdio: "ignore", windowsHide: true,
+    });
+    killer.on("error", plain);
+    killer.on("exit", (code) => { if (code !== 0) plain(); });
+    killer.unref?.();
+  } catch {
+    plain();
+  }
+}
 // Reasons to try the next candidate spelling rather than give up. EINVAL and
 // UNKNOWN show up on Windows for a file that exists but cannot be executed the
 // way it was asked for; both mean "not this one", not "no such tool".
@@ -124,7 +165,15 @@ export function run(cmd, args, { timeout = 20_000, maxBuffer = 4 << 20 } = {}) {
         ? viaCmd(raw, args)
         : { file: raw, args, opts: {} };
+      // execFile's own `timeout` ends with one signal to the process it
+      // started, which for a batch candidate is the cmd.exe wrapper: the
+      // deadline was reported as enforced while the tool underneath went on
+      // running. A batch candidate is timed here instead, on the whole tree.
+      const tree = isBatch(raw);
+      let timer = null, timedOut = false;
       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 ?? ""}`);
@@ -135,14 +184,21 @@ export function run(cmd, args, { timeout = 20_000, maxBuffer = 4 << 20 } = {}) {
           // A tool cmd.exe could not find is missing, not "exited 1" — callers
           // key their message off this.
           code: missing ? "ENOENT" : (err?.code ?? 0),
-          killed: Boolean(err?.killed),
+          // Our own tree kill is not `killed` as far as execFile can tell, so
+          // a timeout reports the same either way.
+          killed: Boolean(err?.killed) || timedOut,
           stdout: String(stdout ?? ""),
           stderr: String(stderr ?? ""),
         });
       };
       try {
-        execFile(file, argv, { timeout, shell: false, windowsHide: true, maxBuffer, ...opts }, done);
+        const cp = execFile(file, argv,
+          { timeout: tree ? 0 : timeout, shell: false, windowsHide: true, maxBuffer, ...opts }, done);
+        if (tree) {
+          timer = setTimeout(() => { timedOut = true; killTree(cp); }, timeout);
+          timer.unref?.();
+        }
       } catch (err) {
         // Synchronous throw — the EINVAL case. Same handling as a callback
         // error; letting it propagate here is what crashed the server, because
@@ -210,7 +266,7 @@ export function runInteractive(cmd, args, { timeout = 300_000, maxOutput = 256 <
   const timer = setTimeout(() => {
     timedOut = true;
-    try { child?.kill(); } catch { /* already gone */ }
+    killTree(child);
   }, timeout);
   timer.unref?.();
@@ -287,9 +343,11 @@ export function runInteractive(cmd, args, { timeout = 300_000, maxOutput = 256 <
     end() {
       try { child?.stdin?.end(); } catch { /* already closed */ }
     },
+    /** Stop the run. On Windows that means the tool under the cmd.exe wrapper
+     *  too — see killTree; a cancelled sign-in used to leave it running. */
     kill() {
       killed = true;
-      try { child?.kill(); } catch { /* already gone */ }
+      killTree(child);
     },
     onLine(cb) { lineSubs.push(cb); },
     done,

package/src/server/self-update.mjs CHANGED Viewed

@@ -25,6 +25,7 @@ import { accessSync, constants as FS, existsSync, mkdirSync, readFileSync, write
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { killTree } from "./exec.mjs";
 // Once an hour, not once a day.
 //
@@ -395,7 +396,10 @@ export function startUpgrade({ pkgRoot, name = "agents-deck" }) {
   child.stdout.on("data", d => keepTail(String(d)));
   child.stderr.on("data", d => keepTail(String(d)));
-  const timer = setTimeout(() => { try { child.kill(); } catch { /* gone */ } }, INSTALL_TIMEOUT_MS);
+  // 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);
   timer.unref?.();
   child.on("error", (e) => {