agent-dag 1.29.1 → 1.30.0

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.29.1",
+  "version": "1.30.0",
   "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/claude-accounts.mjs

@@ -13,10 +13,11 @@
 // means the deck cannot 429 the user's account, cannot burn a refresh token,
 // and cannot lose a login. Switching shells out to `cswap` rather than
 // reimplementing the lock protocol its correctness depends on.
-import { readFile } from "node:fs/promises";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { cswapBin, cswapVersion, installHint } from "./cswap-install.mjs";
 import { run, runDetached } from "./exec.mjs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
 import { homedir, platform } from "node:os";
 
 // claude-swap keeps its store under XDG on Linux and in the home directory
@@ -220,3 +221,79 @@ export function switchClaudeAccount(accountNum) {
       return { ok: false, reason, output: (r.stderr || r.stdout).trim().slice(0, 500) };
     });
 }
+
+
+/**
+ * Register the account already signed in, the first time and only the first
+ * time.
+ *
+ * A fresh install leaves claude-swap with an empty store, so the panel comes up
+ * saying "no accounts added yet" and telling the user to run `cswap add`
+ * themselves — for the account they are already using, on the machine they are
+ * already on. Running it for them is the difference between the panel working
+ * and the panel being a to-do item.
+ *
+ * `cswap add` takes no arguments, prompts for nothing, and does not sign
+ * anyone in: it records the Claude Code session that already exists. Even so it
+ * is bounded tightly, because it writes to a credential store:
+ *
+ *   - only when the store holds no accounts at all, so nothing can be
+ *     overwritten or reordered;
+ *   - only once ever, marked on disk, so a user who deliberately removes their
+ *     last account does not get it added back on the next launch;
+ *   - never when AGENTS_DECK_NO_INSTALL=1.
+ *
+ * Failure is normal and quiet: on a machine where Claude Code has never signed
+ * in there is nothing to record.
+ */
+const SEED_MARKER = join(homedir(), ".agents-deck", ".cswap-seeded");
+
+/**
+ * How many accounts a sequence.json holds.
+ *
+ * claude-swap writes `accounts` as an object keyed by slot number — {"2": {…},
+ * "3": {…}} — not as a list. An Array.isArray guard here read that as "no
+ * accounts" and ran `cswap add` against a populated store, which is exactly
+ * what the guard existed to prevent. Both shapes are accepted now, and
+ * anything unrecognised counts as -1: unknown is not the same as empty, and
+ * only a confident zero may lead to a write.
+ */
+export function accountCount(seq) {
+  const a = seq?.accounts;
+  if (Array.isArray(a)) return a.length;
+  if (a && typeof a === "object") return Object.keys(a).length;
+  if (a == null && seq && typeof seq === "object") return 0;   // store exists, no accounts yet
+  return -1;                                                    // unreadable — do nothing
+}
+
+export async function seedFirstAccount() {
+  if (process.env.AGENTS_DECK_NO_INSTALL === "1") return { state: "skipped" };
+  if (existsSync(SEED_MARKER)) return { state: "already-tried" };
+
+  // Empty store only. A store with accounts in it is the user's, not ours, and
+  // a store we cannot parse is treated the same way.
+  // No file at all is the fresh install this exists for; a file that will not
+  // parse is a store in an unknown state. readJson answers null to both, so
+  // they are told apart before deciding, because they call for opposite
+  // decisions — seed, and keep well away.
+  const seqPath = join(backupRoot(), "sequence.json");
+  const before = existsSync(seqPath) ? accountCount(await readJson(seqPath)) : 0;
+  if (before > 0) return { state: "has-accounts", count: before };
+  if (before < 0) return { state: "unreadable-store" };
+
+  // Mark before running, not after: if `cswap add` half-succeeds or the process
+  // dies mid-way, the retry-forever loop is the worse outcome.
+  try {
+    await mkdir(dirname(SEED_MARKER), { recursive: true });
+    await writeFile(SEED_MARKER, new Date().toISOString());
+  } catch { /* best-effort — worst case it is attempted again */ }
+
+  const r = await run(await cswapBin(), ["add"], { timeout: 60_000 });
+  if (!r.ok) {
+    return { state: "failed", detail: (r.stderr || r.stdout).trim().slice(0, 200) };
+  }
+
+  invalidateClaudeAccountsCache();
+  const count = existsSync(seqPath) ? accountCount(await readJson(seqPath)) : 0;
+  return count > 0 ? { state: "added", count } : { state: "nothing-to-add" };
+}

package/src/server/exec.mjs

@@ -6,10 +6,18 @@
 // ENOENT on Windows even though the tool is installed and on PATH — which
 // looks exactly like "not installed" and is why this is worth a module.
 //
-// The alternative, `shell: true`, would work but concatenates arguments into a
-// command line instead of passing them as a vector: an argument containing a
-// quote or an ampersand stops being an argument. Resolving the extension
-// ourselves keeps the argument vector intact.
+// Resolving the extension ourselves keeps the argument vector intact, which
+// blanket `shell: true` would not: it concatenates arguments into a command
+// line, so an argument containing a quote or an ampersand stops being an
+// argument.
+//
+// The exception is .cmd and .bat, which since Node 20.12 CANNOT be spawned
+// without a shell at all — the fix for CVE-2024-27980 makes that throw EINVAL,
+// synchronously, from inside execFile. Those are routed through cmd.exe the
+// same way Node's own `shell: true` does it, with the arguments quoted here
+// rather than pasted together. Getting this wrong is not a degraded feature:
+// the throw escaped the retry path and took the whole process down on Windows
+// before the server ever started.
 import { execFile, spawn } from "node:child_process";
 
 // Extensions Windows will execute, most specific first. `.com` is omitted —
@@ -28,29 +36,75 @@ function candidates(cmd) {
   return known ? [known] : WIN_EXTS.map(ext => cmd + ext);
 }
 
-const isMissing = (err) => err && (err.code === "ENOENT" || err.code === "EACCES");
+/** Exported for tests: the platform is a parameter so both can be checked. */
+export const isBatch = (file, platform = process.platform) =>
+  platform === "win32" && /\.(cmd|bat)$/i.test(file);
 
 /**
- * Run a command and collect its output. Never rejects — failures come back as
- * `{ ok: false }`, because every caller here is a poll or a UI action where a
- * missing tool is an expected state rather than an exception.
+ * Rewrite a batch-file invocation as a cmd.exe one.
+ *
+ * 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.
+ */
+export function viaCmd(file, args) {
+  const q = (s) => `"${String(s).replace(/"/g, '""')}"`;
+  const line = [file, ...args].map(q).join(" ");
+  return {
+    file: process.env.comspec || process.env.ComSpec || "cmd.exe",
+    args: ["/d", "/s", "/c", `"${line}"`],
+    opts: { windowsVerbatimArguments: true },
+  };
+}
+
+// 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".
+export const tryNext = (err) =>
+  Boolean(err) && (err.code === "ENOENT" || err.code === "EACCES" ||
+                   err.code === "EINVAL" || err.code === "UNKNOWN");
+
+/**
+ * Run a command and collect its output. Never rejects, and never throws —
+ * failures come back as `{ ok: false }`, because every caller here is a poll or
+ * a UI action where a missing tool is an expected state rather than an
+ * exception. execFile can throw synchronously on Windows, so the call itself is
+ * guarded as well as its callback.
  */
 export function run(cmd, args, { timeout = 20_000, maxBuffer = 4 << 20 } = {}) {
   const tries = candidates(cmd);
   return new Promise((resolve) => {
     const attempt = (i) => {
-      execFile(tries[i], args, { timeout, shell: false, windowsHide: true, maxBuffer },
-        (err, stdout, stderr) => {
-          if (err && isMissing(err) && i + 1 < tries.length) return attempt(i + 1);
-          if (!err) resolved.set(cmd, tries[i]);
-          resolve({
-            ok: !err,
-            code: err?.code ?? 0,
-            killed: Boolean(err?.killed),
-            stdout: String(stdout ?? ""),
-            stderr: String(stderr ?? ""),
-          });
+      if (i >= tries.length) {
+        return resolve({ ok: false, code: "ENOENT", killed: false, stdout: "", stderr: "" });
+      }
+      const raw = tries[i];
+      const { file, args: argv, opts } = isBatch(raw)
+        ? viaCmd(raw, args)
+        : { file: raw, args, opts: {} };
+
+      const done = (err, stdout, stderr) => {
+        if (err && tryNext(err) && i + 1 < tries.length) return attempt(i + 1);
+        if (!err) resolved.set(cmd, raw);
+        resolve({
+          ok: !err,
+          code: err?.code ?? 0,
+          killed: Boolean(err?.killed),
+          stdout: String(stdout ?? ""),
+          stderr: String(stderr ?? ""),
         });
+      };
+
+      try {
+        execFile(file, argv, { timeout, shell: false, windowsHide: true, maxBuffer, ...opts }, done);
+      } catch (err) {
+        // Synchronous throw — the EINVAL case. Same handling as a callback
+        // error; letting it propagate here is what crashed the server, because
+        // this runs inside the previous attempt's error handler.
+        done(err, "", "");
+      }
     };
     attempt(0);
   });
@@ -64,15 +118,18 @@ export function run(cmd, args, { timeout = 20_000, maxBuffer = 4 << 20 } = {}) {
 export function runDetached(cmd, args) {
   const tries = candidates(cmd);
   const attempt = (i) => {
+    if (i >= tries.length) return;
+    const raw = tries[i];
+    const { file, args: argv, opts } = isBatch(raw)
+      ? viaCmd(raw, args)
+      : { file: raw, args, opts: {} };
     try {
-      const child = spawn(tries[i], args, { stdio: "ignore", shell: false, windowsHide: true });
-      child.on("error", (err) => {
-        if (isMissing(err) && i + 1 < tries.length) attempt(i + 1);
-      });
-      child.on("spawn", () => resolved.set(cmd, tries[i]));
+      const child = spawn(file, argv, { stdio: "ignore", shell: false, windowsHide: true, ...opts });
+      child.on("error", (err) => { if (tryNext(err)) attempt(i + 1); });
+      child.on("spawn", () => resolved.set(cmd, raw));
       child.unref?.();
     } catch {
-      if (i + 1 < tries.length) attempt(i + 1);
+      attempt(i + 1);
     }
   };
   attempt(0);