agent-dag 1.43.0 → 1.45.0

package/src/server/exec.mjs

@@ -63,8 +63,9 @@ export const isBatch = (file, platform = process.platform) =>
  * Mirrors what Node does internally for `shell: true` on Windows — comspec,
  * /d /s /c, the whole command line as a single quoted argument, and
  * windowsVerbatimArguments so Node does not quote it a second time. Each
- * argument is quoted here, with embedded quotes doubled, which is the escape
- * cmd.exe understands inside a quoted string.
+ * argument is quoted by shellQuoteArg below, which has to satisfy cmd.exe AND
+ * the argv parser of whatever it launches — see the note there, and #624 for
+ * the half of that rule this file was missing until a real cmd.exe was asked.
  */
 export function viaCmd(file, args) {
   const line = [file, ...args].map(a => shellQuoteArg(a, "win32")).join(" ");
@@ -98,17 +99,61 @@ export function viaCmd(file, args) {
  *
  * POSIX gets single quotes, inside which NOTHING is special, with the one
  * escape that form has: close the quote, emit a backslash-quote, reopen.
- * Windows gets cmd.exe's rule — the same one viaCmd applies above, so this file
- * has one Windows quoting rule rather than two — with the same single residual
- * exec.mjs already documents: cmd.exe expands `%VAR%` inside quotes too, and a
- * command line has no escape for it. That is narrower than it sounds, since
- * `%foo%` with no variable `foo` is left alone, and it is a limit of the
- * platform rather than of this function.
+ *
+ * Windows gets the rule below — the same one viaCmd applies above, so this file
+ * has one Windows quoting rule rather than two. It has to satisfy TWO parsers,
+ * and that is the whole of its difficulty, because they disagree about the
+ * backslash:
+ *
+ *   cmd.exe reads the line only far enough to find where the command ends. It
+ *   has no escape for a quote at all — a `"` toggles "inside quotes", and `&`,
+ *   `|`, `<`, `>`, `^`, `(` and `)` are syntax only while outside — and it does
+ *   not treat `\` as anything. Then it hands the rest of the line on AS TEXT.
+ *
+ *   The program on the other end splits that text into argv itself, and for
+ *   node that is the UCRT parser, which DOES read `\` as an escape in front of
+ *   a quote: 2n backslashes before a `"` are n backslashes and a quote that
+ *   toggles, 2n+1 are n backslashes and a literal `"`.
+ *
+ * So an embedded `"` is written `""` rather than `\"` — two toggles is no net
+ * change to cmd.exe's idea of where it is, while the child's parser turns the
+ * pair back into one quote — and every run of backslashes that ends up in front
+ * of a quote, INCLUDING THE CLOSING ONE THIS ADDS, is doubled so the child does
+ * not read it as an escape.
+ *
+ * That last clause is #624 and it was missing. `"` + arg + `"` alone turns a
+ * path ending in a separator — `C:\Program Files\nodejs\` — into
+ * `"C:\Program Files\nodejs\"`, whose final `\"` is an escaped quote to the
+ * child: the quoted region never closes, and the argument swallows every
+ * argument after it on the line. `--provider claude` in the hook command is
+ * exactly what it swallowed. A backslash immediately before an embedded quote
+ * was the quieter half of the same defect — it was eaten as the escape.
+ *
+ * The one residual left, unchanged: cmd.exe expands `%VAR%` inside quotes too,
+ * and a command line has no escape for it. That is narrower than it sounds,
+ * since `%foo%` with no variable `foo` is left alone, and it is a limit of the
+ * platform rather than of this function. `!VAR!` is the same limit on a machine
+ * with delayed expansion turned on, which is not the default for `cmd /c`.
+ *
+ * no-shell-hook-commands.test.ts runs the output of this through a real cmd.exe
+ * on the Windows leg of the matrix and compares what the child RECEIVED against
+ * what was intended. Four literals said this function agreed with itself for
+ * three releases; they could not say whether it agreed with Windows.
  */
 export function shellQuoteArg(arg, platform = process.platform) {
   const s = String(arg ?? "");
-  if (platform === "win32") return `"${s.replace(/"/g, '""')}"`;
-  return `'${s.split("'").join("'\\''")}'`;
+  if (platform !== "win32") return `'${s.split("'").join("'\\''")}'`;
+  let out = '"';
+  let slashes = 0;
+  for (const ch of s) {
+    if (ch === "\\") { slashes++; continue; }
+    if (ch === '"') { out += "\\".repeat(slashes * 2) + '""'; slashes = 0; continue; }
+    out += "\\".repeat(slashes) + ch;
+    slashes = 0;
+  }
+  // A run that reaches the end of the argument is in front of the closing quote,
+  // which is a quote like any other.
+  return `${out}${"\\".repeat(slashes * 2)}"`;
 }
 
 /**
@@ -340,13 +385,40 @@ 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.
+// The three lines an ENGLISH 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.
+//
+// These are one signal out of three rather than the whole answer — see
+// looksMissing. Windows ships cmd.exe in every language it ships in, and these
+// sentences are translated with it.
 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's own errorlevel for a command token it could not resolve — the one
+// signal here that is not a human sentence, and therefore the only one that is
+// the same on a German install as on an English one. It is the number every CI
+// log in the world prints beside "is not recognized".
+//
+// Not every path reports it: some Windows builds answer a bare `cmd /c missing`
+// with a plain 1 instead, which is why this is a sufficient signal and never a
+// necessary one. A number this large cannot arrive from POSIX at all — a process
+// exit status there is masked to 0-255 before Node ever sees it — so nothing
+// outside cmd.exe can reach it by accident.
+const CMD_NOT_FOUND_EXIT = 9009;
+
+/** True when an exit status is cmd.exe saying "no such command", in any locale. */
+export const notFoundExit = (code) => Number(code) === CMD_NOT_FOUND_EXIT;
+
+// Every run of text this line wrapped in quotes. cmd.exe quotes the command
+// token it could not find in EVERY locale, and the quote character is the only
+// part of the message that is not a translation: `'…'` in English and French,
+// `"…"` in German, Spanish, Italian, Portuguese, Polish and Russian.
+const quotedRuns = (line) =>
+  [...String(line).matchAll(/'([^']+)'|"([^"]+)"/g)].map(m => m[1] ?? m[2]);
+
 // 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.
@@ -409,20 +481,108 @@ const sameCommand = (quoted, name) => {
  *
  * Callers that only have the text (failureText) omit it and get the shape rules
  * alone.
+ *
+ * ── AND NOT ONLY IN ENGLISH (#552) ──────────────────────────────────────────
+ *
+ * Everything above was written against three English sentences, and cmd.exe is
+ * translated. On a German install with cswap genuinely absent it prints
+ *
+ *     Der Befehl "cswap" ist entweder falsch geschrieben oder konnte nicht
+ *     gefunden werden.
+ *
+ * — so this answered false, `run` resolved `{ ok: false, code: 1 }`,
+ * claude-accounts.mjs picked `reason: "switch_failed"` over `"no_cswap"` and the
+ * panel's install affordance never appeared. failureText then fell through to
+ * firstUseful, which puts the LAST line of a localized sentence on screen by
+ * itself: #457's symptom reproduced for every non-English locale. It also
+ * stopped the candidate loop early, so a `.bat` installed after a missing `.cmd`
+ * was never reached.
+ *
+ * Adding the German sentence, and then the French and the Japanese ones, is not
+ * a fix — it is the same defect with a longer list. So two signals that are not
+ * sentences carry the answer instead, and the English text is what remains when
+ * neither is available:
+ *
+ *   1. THE EXIT STATUS. `exitCode` 9009 is cmd.exe's own errorlevel for a
+ *      command token it could not resolve, identical in every language. See
+ *      CMD_NOT_FOUND_EXIT for why it is not required, and the paragraph below
+ *      for the two cases where it is not believed either. It is subject to the
+ *      same "cmd.exe printed nothing else" cap as rule 2, because a status is
+ *      forwarded as easily as a sentence is.
+ *
+ *   2. THE SHAPE. cmd.exe quotes the command it could not find, in every locale,
+ *      and prints that INSTEAD of running anything — so the whole output is at
+ *      most the two lines of one wrapped sentence. Text of at most two lines
+ *      whose FIRST line quotes exactly the spelling we launched is cmd.exe's
+ *      verdict about our command whatever the words around it say.
+ *
+ * Rule 2 needs `name`, and refuses without it. That is the same principle the
+ * paragraphs above argue for and not a limitation bolted on: `Error: "account-9"
+ * does not exist` is one line with a quoted token in it, and read as an absence
+ * it would send the candidate loop back round to re-run `cswap remove 3`. What
+ * makes the rule safe is that the quoted token has to be the exact spelling
+ * cmd.exe was handed — `cswap.cmd`, or the absolute path shimPath found — which
+ * is a string the tool underneath has no reason to print. The two-line cap is
+ * the other half: a Python traceback ending in "The system cannot find the file
+ * specified" is four lines and can never qualify.
+ *
+ * THE SAME TRAP THE ENGLISH RULE ALREADY AVOIDS, NOW FOR THE EXIT STATUS. A
+ * `.cmd` shim is itself a batch file, so a shim that EXISTS and whose payload
+ * interpreter does not — a scoop or npm-style `cswap.cmd` in front of a python
+ * that was uninstalled — has cmd.exe print "is not recognized" about PYTHON and
+ * hands the shim's caller that same 9009. Believed on its own, the deck would
+ * call the tool absent and re-run the command under the next spelling. So a text
+ * that positively names a command OTHER than ours vetoes every rule here,
+ * including the status: the check that made #457 safe, applied one level up.
+ *
+ * What is deliberately still missed: a LOCALIZED "the system cannot find the
+ * path specified", which carries no quoted token and no structure to key off.
+ * That case only arises when shimPath found a shim that then vanished, and it
+ * fails in the safe direction — an honest exit 1 rather than a wrong ENOENT.
  */
-export function looksMissing(text, name = "") {
+export function looksMissing(text, name = "", exitCode = null) {
   const lines = String(text ?? "").split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+  // Whatever cmd.exe named, in whatever language it said the rest — the quoting
+  // is the part that is not a translation.
+  const named = lines.length ? quotedRuns(lines[0]) : [];
+  const namesUs = named.some(q => sameCommand(q, name));
+
+  // The veto, before anything is believed: a message about somebody else's
+  // command is not evidence about ours, and neither is the status that came
+  // with it. See the header — a `.cmd` shim in front of a missing interpreter
+  // forwards both.
+  if (name && named.length > 0 && !namesUs) return false;
+
+  // cmd.exe says this INSTEAD of running anything, so anything longer than one
+  // wrapped sentence came from something that DID run — and that outranks both
+  // signals below. A shim can forward its child's 9009 after printing pages of
+  // its own; a Python traceback is four lines and one of them quotes the very
+  // shim we launched.
+  const saidNothingElse = lines.length <= 2;
+
+  // The signal that is not a sentence. It does not need to READ the text, which
+  // is the whole reason it exists: on a non-English install there may be nothing
+  // in the text this can read.
+  if (saidNothingElse && notFoundExit(exitCode)) return true;
   if (!lines.length) return false;
+
+  // The English shapes, whole-line anchored, exactly as before.
+  let english = true;
   for (const line of lines) {
-    const named = CMD_UNKNOWN.exec(line);
-    if (named) {
-      if (name && !sameCommand(named[1], name)) return false;
+    const unknown = CMD_UNKNOWN.exec(line);
+    if (unknown) {
+      if (name && !sameCommand(unknown[1], name)) return false;
       continue;
     }
     if (CMD_UNKNOWN_TAIL.test(line) || CMD_NO_PATH.test(line)) continue;
-    return false;
+    english = false;
+    break;
   }
-  return true;
+  if (english) return true;
+
+  // Otherwise: cmd.exe in some other language, recognised by its shape and by
+  // the one word in it that is ours.
+  return Boolean(name) && saidNothingElse && namesUs;
 }
 
 // How much of a hung child's output the deadline keeps. The full buffers belong
@@ -485,7 +645,11 @@ export function run(cmd, args, { timeout = 20_000, maxBuffer = 4 << 20, env } =
         // 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 ?? ""}`, launch);
+        // `err.code` is the exit STATUS for a child that ran and failed, which
+        // is where cmd.exe's language-independent 9009 arrives; for a spawn
+        // failure it is an errno string, and Number() of that is NaN. Either
+        // way looksMissing is handed what the attempt actually reported.
+        const missing = Boolean(err) && tree && looksMissing(`${stderr ?? ""}\n${stdout ?? ""}`, launch, err.code);
         if (err && (tryNext(err) || missing) && i + 1 < tries.length) return attempt(i + 1);
         // The CANDIDATE is what gets remembered, never the resolved path. The
         // memo is the only entry `candidates` offers afterwards, so recording an
@@ -561,14 +725,17 @@ export function run(cmd, args, { timeout = 20_000, maxBuffer = 4 << 20, env } =
  *
  * Returns immediately with a handle:
  *   write(text)  — into the child's stdin
- *   kill()       — give up; `done` still settles
+ *   kill()       — give up; `done` settles within killGrace either way
  *   onLine(cb)   — every complete stdout/stderr line as it arrives
  *   done         — Promise<{ok, code, killed, timedOut, stdout, stderr}>
  *
- * Never rejects, for the same reason `run` never does. Same Windows candidate
- * resolution, since `claude` and `cswap` are `.cmd` shims there.
+ * Never rejects, for the same reason `run` never does. And never stays pending:
+ * the deadline answers with `code: "ETIMEDOUT", timedOut: true` at the moment
+ * it expires rather than waiting on a 'close' a surviving descendant can hold
+ * back forever — see the timer below, and #614 for what that cost. Same Windows
+ * candidate resolution, since `claude` and `cswap` are `.cmd` shims there.
  */
-export function runInteractive(cmd, args, { timeout = 300_000, maxOutput = 256 << 10 } = {}) {
+export function runInteractive(cmd, args, { timeout = 300_000, maxOutput = 256 << 10, killGrace = 2_000 } = {}) {
   const tries = candidates(cmd);
   const lineSubs = [];
   let child = null;
@@ -596,15 +763,39 @@ export function runInteractive(cmd, args, { timeout = 300_000, maxOutput = 256 <
     }
   };
 
+  let graceTimer = null;
+
   const finish = (code, err) => {
     if (!settle) return;
     const s = settle; settle = null;
     clearTimeout(timer);
+    clearTimeout(graceTimer);
     s({ ok: code === 0 && !err && !timedOut, code: err?.code ?? code ?? -1, killed, timedOut, stdout, stderr });
   };
 
+  // The deadline states the outcome and only then kills — the order `run` uses
+  // forty lines above, for the reason its own header already spells out.
+  //
+  // This used to set the flag, kill, and leave `done` to the child's 'close'.
+  // 'close' waits for the stdio pipes, not merely for the exit, so ONE
+  // descendant that outlives the kill holding the inherited stdout keeps it
+  // from ever arriving: the child is dead, the promise is pending, and it stays
+  // pending for the life of the process. On Windows that is the ordinary shape
+  // rather than a corner — a `.cmd` shim runs the real tool as a grandchild
+  // under cmd.exe, so a taskkill that cannot run reaches only the wrapper — and
+  // on macOS/Linux any cswap subprocess still alive when SIGTERM lands does it.
+  //
+  // What it cost: both callers await this INSIDE withStoreLock, so the pending
+  // promise is the accounts mutex. Every later mutation — login, cancel,
+  // import, remove, alias, reorder — queued behind a link that would never
+  // settle, the HTTP request was never answered, and spawnLogin's
+  // process-on-exit handler leaked with the promise. Reported as #614.
   const timer = setTimeout(() => {
     timedOut = true;
+    killed = true;
+    // Whatever the child managed to print rides along, the way run()'s tail
+    // does: it had not finished, but it is all a caller has to go on.
+    finish(-1, { code: "ETIMEDOUT" });
     killTree(child);
   }, timeout);
   timer.unref?.();
@@ -658,12 +849,18 @@ export function runInteractive(cmd, args, { timeout = 300_000, maxOutput = 256 <
     proc.stderr?.on("data", (d) => { if (stale()) return; const t = String(d); stderr = keep(stderr, t); emitLines(t); });
     proc.on("close", (code) => {
       if (stale()) return;
+      // Already answered — by the deadline above, or by kill()'s grace below.
+      // A late 'close' has nothing left to report, and this is not merely
+      // tidiness: the retry underneath re-runs the WHOLE command, and re-running
+      // `cswap remove` on behalf of a promise nobody is waiting for any more is
+      // exactly the thing that must not happen.
+      if (!settle) 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. 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}`, launch)) {
+      if (code !== 0 && isBatch(raw) && looksMissing(`${stderr}\n${stdout}`, launch, code)) {
         if (i + 1 < tries.length) {
           stdout = ""; stderr = ""; pending = "";
           child = null;
@@ -689,10 +886,20 @@ export function runInteractive(cmd, args, { timeout = 300_000, maxOutput = 256 <
       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. */
+     *  too — see killTree; a cancelled sign-in used to leave it running.
+     *
+     *  `done` settles either way. The kill cannot promise the pipes close —
+     *  that is the deadline's problem reached from the other side — so if the
+     *  child's own 'close' has not arrived within killGrace, the handle answers
+     *  without it. A cancelled sign-in must not be able to wedge the accounts
+     *  mutex any more than an expired one. */
     kill() {
       killed = true;
       killTree(child);
+      if (settle && !graceTimer) {
+        graceTimer = setTimeout(() => finish(-1, null), killGrace);
+        graceTimer.unref?.();
+      }
     },
     onLine(cb) { lineSubs.push(cb); },
     done,