agent-dag 1.26.0 → 1.28.0

package/src/server/exec.mjs

@@ -0,0 +1,79 @@
+// Running an external command the same way on Linux, macOS and Windows.
+//
+// On POSIX, `spawn("cswap", …)` finds cswap on PATH. On Windows it does not:
+// the thing on PATH is `cswap.exe` or a `cswap.cmd` shim, and Node only
+// applies PATHEXT when it goes through a shell. So the naive call fails with
+// 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.
+import { execFile, spawn } from "node:child_process";
+
+// Extensions Windows will execute, most specific first. `.com` is omitted —
+// nothing ships one, and every extra candidate costs a failed spawn.
+const WIN_EXTS = [".exe", ".cmd", ".bat", ""];
+
+// Which spelling worked, per command name. A failed spawn is cheap but not
+// free, and these run on a poll.
+const resolved = new Map();
+
+function candidates(cmd) {
+  if (process.platform !== "win32") return [cmd];
+  // An explicit extension is respected as given.
+  if (/\.[a-z]+$/i.test(cmd)) return [cmd];
+  const known = resolved.get(cmd);
+  return known ? [known] : WIN_EXTS.map(ext => cmd + ext);
+}
+
+const isMissing = (err) => err && (err.code === "ENOENT" || err.code === "EACCES");
+
+/**
+ * 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.
+ */
+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 ?? ""),
+          });
+        });
+    };
+    attempt(0);
+  });
+}
+
+/**
+ * Start a command and don't wait for it. Same resolution, no output captured.
+ * Used where the result lands somewhere else — a file the next poll reads, or
+ * a sound the user hears.
+ */
+export function runDetached(cmd, args) {
+  const tries = candidates(cmd);
+  const attempt = (i) => {
+    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]));
+      child.unref?.();
+    } catch {
+      if (i + 1 < tries.length) attempt(i + 1);
+    }
+  };
+  attempt(0);
+}

package/src/server/index.mjs

@@ -1123,13 +1123,14 @@ async function handleSoundHook(req, res) {
 }
 
 async function handleSoundHookSet(req, res) {
-  const { setSoundHook } = await import(
+  const { setSoundHook, restoreParkedSoundHooks } = await import(
     pathToFileURL(join(PKG_ROOT, "src/server/sound-hook.mjs")).href
   );
   const body = await readBody(req).catch(() => null);
   let parsed = null;
   try { parsed = JSON.parse(body ?? ""); } catch { /* handled below */ }
   if (!parsed || typeof parsed !== "object") return send(res, 400, { ok: false, reason: "bad_request" });
+  if (parsed.action === "restore") return send(res, 200, await restoreParkedSoundHooks());
   send(res, 200, await setSoundHook(parsed.enabled === true));
 }
 

package/src/server/quota.mjs

@@ -264,7 +264,12 @@ async function _execOnce(shellCmd) {
   try {
     const { stdout, stderr } = await execAsync(shellCmd, {
       timeout: 15_000,
-      env: { ...process.env, NO_COLOR: "1", TERM: "dumb" },
+      // Marks this Claude Code run as the deck's own. `claude --print /usage`
+      // is a full invocation, so it fires the hooks we installed, and every
+      // quota poll was drawing itself onto the canvas as a fresh session with
+      // no prompt and no tools. Hooks inherit the environment, so hook.js
+      // sees this and stays quiet.
+      env: { ...process.env, NO_COLOR: "1", TERM: "dumb", AGENTS_DECK_INTERNAL: "1" },
       maxBuffer: 1024 * 1024,
     });
     const combined = stdout + "\n" + stderr;

package/src/server/sound-hook.mjs

@@ -24,6 +24,9 @@ const NOTIFY_PATH   = join(INSTALL_DIR, "notify.js");
 
 const MARK = "__agent-dag-sound";
 const EVENT = "Stop";
+// Where a user's own sound hooks are kept while the toggle is off, so turning
+// the feature off actually produces silence and nothing is destroyed.
+const PARKED_PATH = join(homedir(), ".agents-deck", "parked-sound-hooks.json");
 
 // Commands that look like a hand-rolled sound hook. Used only to tell the user
 // what is already there — never to modify or remove it.
@@ -73,22 +76,79 @@ function foreignSoundHooks(settings) {
   return found;
 }
 
+async function readParked() {
+  try {
+    const parsed = JSON.parse(await readFile(PARKED_PATH, "utf8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch { return []; }
+}
+
+async function writeParked(entries) {
+  try {
+    if (!existsSync(dirname(PARKED_PATH))) await mkdir(dirname(PARKED_PATH), { recursive: true });
+    await writeFile(PARKED_PATH, JSON.stringify(entries, null, 2) + "\n", "utf8");
+  } catch { /* best-effort */ }
+}
+
+/**
+ * True when this Stop entry plays a sound, on any platform.
+ *
+ * Deliberately not limited to the current one. settings.json is commonly
+ * synced between machines — this user's own file carries Windows paths
+ * alongside macOS ones — so parking only the hook that fires here leaves the
+ * other in place, and the switch looks broken again on the other machine.
+ */
+function isSoundHook(entry) {
+  if (isOurs(entry)) return false;
+  return (entry.hooks ?? []).some(h =>
+    SOUND_HINTS.some(re => re.test(typeof h?.command === "string" ? h.command : "")));
+}
+
 export async function soundHookStatus() {
   const settings = await readSettings();
   const group = settings?.hooks?.[EVENT];
+  const parked = await readParked();
   return {
     ok: true,
     enabled: Array.isArray(group) && group.some(isOurs),
     platform: process.platform,
     foreign: foreignSoundHooks(settings),
+    parked: parked.length,
   };
 }
 
+/**
+ * Put back the hooks the toggle set aside.
+ *
+ * Nothing is deleted, only moved, so a user who preferred their own command
+ * can have it back exactly as it was.
+ */
+export async function restoreParkedSoundHooks() {
+  const parked = await readParked();
+  if (parked.length === 0) return { ok: true, restored: 0 };
+  const settings = await readSettings();
+  settings.hooks ??= {};
+  const group = Array.isArray(settings.hooks[EVENT]) ? settings.hooks[EVENT] : [];
+  settings.hooks[EVENT] = [...parked, ...group];
+  await writeSettings(settings);
+  await writeParked([]);
+  return { ok: true, restored: parked.length };
+}
+
 export async function setSoundHook(enabled) {
   const settings = await readSettings();
   settings.hooks ??= {};
   const group = Array.isArray(settings.hooks[EVENT]) ? settings.hooks[EVENT] : [];
-  const others = group.filter(g => !isOurs(g));
+
+  // Set aside any of the user's own hooks that play a sound on this machine.
+  // Without this the toggle is a lie in both directions: off still plays their
+  // afplay/PowerShell hook, and on plays twice. They are moved, not deleted —
+  // restoreParkedSoundHooks puts them back untouched.
+  const parking = group.filter(isSoundHook);
+  if (parking.length > 0) {
+    await writeParked([...(await readParked()), ...parking]);
+  }
+  const others = group.filter(g => !isOurs(g) && !isSoundHook(g));
 
   if (enabled) {
     if (!existsSync(INSTALL_DIR)) await mkdir(INSTALL_DIR, { recursive: true });