ccdeck 3.32.1 → 3.33.0

package/src/server/cswap-install.mjs

@@ -20,7 +20,7 @@ import { bootstrapUv, existingBootstrappedUv } from "./uv-bootstrap.mjs";
 // Where installers leave claude-swap and which one owns this machine's copy —
 // pure layout, with the platform a parameter, so it lives on its own.
 import { PKG, cswapCandidates, cswapOwner } from "./cswap-layout.mjs";
-import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
@@ -92,6 +92,98 @@ function sameVersion(a, b) { return !isOlder(a, b) && !isOlder(b, a); }
 
 let _bin = null;
 
+// ── a copy this deck refused ─────────────────────────────────────────────────
+//
+// #1799. installAndConfirm refuses a claude-swap whose version is not the one it
+// asked for, and the refusal used to exist only in the value it returned. The
+// copy was still on disk, cswapBin memoized it the moment it answered
+// `--version`, and everything after the boot row drove it anyway: the roster
+// called it installed-and-empty and offered Add account, `/api/cswap-auto` ran
+// `cswap config` with it, and the NEXT launch could not tell it from a copy the
+// user installed themselves — which ensureCswap deliberately accepts whatever
+// its number — so it read "accounts panel enabled" and was seeded with
+// `cswap add`.
+//
+// So a refusal is written down, next to the update marker, and kept until
+// something changes: while a copy answering the refused version is what
+// resolves, cswapBin hands out REFUSED_BIN instead of it and cswapVersion
+// answers null. It is matched on the VERSION, not on the spelling: the same
+// file answers as `cswap` once ~/.local/bin is on PATH and by its absolute path
+// before, and telling those apart would need a PATH walk to be right in both
+// directions. A copy answering any other version clears the record — that is a
+// different copy, most likely one the user installed, and it is left alone the
+// way any other is — and so does an install that lands an acceptable one.
+// AGENTS_DECK_CSWAP wins over all of it, as it wins over every other lookup
+// here: someone who names a binary has chosen it.
+const REFUSED_RECORD = join(homedir(), ".agents-deck", "cswap-refused.json");
+
+/**
+ * What cswapBin answers while the refusal holds: a path under the deck's own
+ * state directory that nothing creates, with an extension so that Windows spawns
+ * it as given rather than trying `.cmd` spellings through cmd.exe. Every caller
+ * already handles a cswap that is not there, and this is one — so a mutation
+ * that reaches it (an Add pressed from a panel drawn before the refusal) fails
+ * the way a missing tool fails, and runs nothing.
+ */
+const REFUSED_BIN = join(homedir(), ".agents-deck", "cswap-refused", "cswap.refused");
+
+/** The refusal in effect for THIS process, `{ path, version, want, via }` — set
+ *  when an install is refused, or when cswapBin resolves a copy the record
+ *  names. */
+let _refused = null;
+
+function readRefusal() {
+  try {
+    const r = JSON.parse(readFileSync(REFUSED_RECORD, "utf8"));
+    return r && typeof r.version === "string" ? r : null;
+  } catch {
+    return null;
+  }
+}
+
+function clearRefusal() {
+  try { rmSync(REFUSED_RECORD, { force: true }); } catch { /* best-effort */ }
+}
+
+/** Refuse this copy from now on, in this process and in the next. */
+function refuse(entry) {
+  _refused = entry;
+  _bin = null;
+  _probe = null;
+  try {
+    mkdirSync(join(homedir(), ".agents-deck"), { recursive: true });
+    writeFileSync(REFUSED_RECORD, JSON.stringify({ ...entry, at: new Date().toISOString() }, null, 2) + "\n");
+  } catch { /* the in-process refusal still holds; a note on disk is the next launch's */ }
+}
+
+/**
+ * The refusal cswapBin's resolution found, or null — `{ path, version, want,
+ * via }`. As of the last cswapBin(), so a caller that has just awaited one can
+ * ask this without another hop; one that has not wants cswapRefusal.
+ */
+export function cswapRefused() {
+  return process.env.AGENTS_DECK_CSWAP ? null : _refused;
+}
+
+/**
+ * The refusal this deck is keeping, or null, for a caller that may be asking
+ * before anything has resolved the binary: the roster and the first-run seed.
+ * Resolves it first only when there is a record to match and nothing has been
+ * resolved yet, so a process pays one `--version` for the question and a
+ * machine with no record pays a missing file.
+ */
+export async function cswapRefusal() {
+  if (process.env.AGENTS_DECK_CSWAP) return null;
+  if (!_refused && !_bin && existsSync(REFUSED_RECORD)) await cswapBin();
+  return _refused;
+}
+
+/** ensureCswap's answer for a refused copy: the install-time row's shape, so
+ *  the boot says the same thing on every launch the refusal holds. */
+function refusedState(r) {
+  return { state: "unavailable", reason: "unexpected_version", version: r.version, want: r.want ?? RANGE_SPEC, via: r.via ?? null };
+}
+
 /**
  * What the probe that resolved `_bin` printed, and when.
  *
@@ -136,9 +228,19 @@ export async function cswapBin() {
   // debugging a bad resolution needs it to take effect immediately.
   if (process.env.AGENTS_DECK_CSWAP) return process.env.AGENTS_DECK_CSWAP;
   if (_bin) return _bin;
+  if (_refused) return REFUSED_BIN;
 
   const take = (spelling, r) => {
-    _probe = { version: versionIn(r), at: Date.now() };
+    const version = versionIn(r);
+    // The copy the deck refused, still answering: decline it (#1799). Any
+    // other version is another copy, and the record goes.
+    const refused = readRefusal();
+    if (refused && refused.version === version) {
+      _refused = refused;
+      return REFUSED_BIN;
+    }
+    if (refused) clearRefusal();
+    _probe = { version, at: Date.now() };
     return (_bin = spelling);
   };
 
@@ -173,11 +275,12 @@ export async function cswapBin() {
  * ensureCswap below, whose return value says nothing about which binary the
  * following twenty account operations will be sent to. See cswap-bin-memo.test.ts.
  */
-export function resetCswapBin() { _bin = null; _probe = null; }
+export function resetCswapBin() { _bin = null; _probe = null; _refused = null; }
 
 /** Installed version string, or null when cswap cannot be found. */
 export async function cswapVersion() {
   const bin = await cswapBin();
+  if (bin === REFUSED_BIN) return null;   // declined, not asked — see _refused
   // The call above may have just asked this very question — see _probe. Nothing
   // is remembered past PROBE_FRESH_MS, so this is the second half of one
   // lookup rather than a cache of the answer.
@@ -600,10 +703,17 @@ export async function ensureCswap({ onInstalling = null } = {}) {
 
   if (process.env.AGENTS_DECK_NO_INSTALL === "1") {
     const version = await cswapVersion();
+    if (cswapRefused()) return refusedState(cswapRefused());
     return version ? { state: "present", version } : { state: "skipped" };
   }
 
   const existing = await cswapVersion();
+  // STILL THE COPY IT REFUSED (#1799). Asked before the existing-install branch,
+  // which accepts any version on purpose and would call this one present, and
+  // before the install below, which would fetch the same answer from the same
+  // index on every launch. The boot row repeats the refusal instead, and nothing
+  // is seeded.
+  if (cswapRefused()) return refusedState(cswapRefused());
   if (existing) {
     // Installed — the only question left is whether it's stale. One PyPI
     // request a day, and the upgrade itself never blocks startup.
@@ -650,6 +760,9 @@ async function installAndConfirm() {
   // found nothing — see resetCswapBin — but a lookup that DID resolve, to a copy
   // whose `--version` then failed, is exactly the case that got us here.
   resetCswapBin();
+  // And whatever was refused before: what arrived is judged below, afresh, and
+  // an acceptable version is the end of the refusal.
+  clearRefusal();
 
   // Freshly installed tools land in ~/.local/bin, which may not be on the PATH
   // of the shell that launched us — cswapBin looks there directly, so this
@@ -675,6 +788,8 @@ async function installAndConfirm() {
   if (version !== "installed") {
     const wrong = result.want ? !sameVersion(version, result.want) : !isAcceptableVersion(version);
     if (wrong) {
+      // Kept, not only reported (#1799): see REFUSED_RECORD.
+      refuse({ path: _bin, version, want: result.want ?? RANGE_SPEC, via: result.via });
       return { state: "unavailable", reason: "unexpected_version", version, want: result.want ?? RANGE_SPEC, via: result.via };
     }
   }

package/src/server/deck-prefs.mjs

@@ -212,6 +212,10 @@ function normaliseLan(raw) {
         // When somebody here said yes. Absent on every pin made before this was
         // kept, and absent is drawn as "before" rather than guessed.
         ...(Number.isFinite(t.at) && t.at > 0 ? { at: t.at } : {}),
+        // Said yes to by the accept switch rather than by a person — see
+        // addTrusted in lan-sync.mjs. Kept, or a restart would turn every
+        // pairing the switch made into one somebody chose. Only a real `true`.
+        ...(t.auto === true ? { auto: true } : {}),
       })),
     // Fingerprints somebody explicitly unpaired. Kept separately from trusted
     // because manual dial rows survive the action and must not silently rebuild

package/src/server/event-pipeline.mjs

@@ -72,6 +72,9 @@ const blockNotifier = createBlockNotifier({
   // menu while the deck is running, and a mute that waited for a restart would
   // not be a mute. The env var still wins inside `notificationsOn`.
   enabled: () => notificationsOn(heldPrefs.current()),
+  // Asked again when the burst cap's window reopens, for the one notice that
+  // stands for what it held back — see BURST_MAX.
+  pages: () => pageCount(),
   onError: err => console.error(`${PRODUCT}: could not raise a desktop notification:`, err?.message ?? err),
 });
 

package/src/server/event-ring.mjs

@@ -8,7 +8,7 @@
 // envelope and evicts behind it, clearEventBuffer empties all three, and the
 // readers get a copy or an answer rather than the array. The bodies are
 // unchanged.
-import { ENVELOPE_CHARS, LAST_VALUE_WINS, MAX_BUFFER, MAX_BUFFER_CHARS, MAX_RING_ENTRIES, payloadChars } from "./ring-bounds.mjs";
+import { ENVELOPE_CHARS, MAX_BUFFER, MAX_BUFFER_CHARS, MAX_RING_ENTRIES, isEnrichment, payloadChars } from "./ring-bounds.mjs";
 
 // ─── The event ring buffer ─────────────────────────────────────────────────
 // Its two bounds, MAX_BUFFER and MAX_BUFFER_CHARS, and the charge an event is
@@ -148,7 +148,7 @@ export function admitEvent(raw, source, receivedAt) {
     // Decided once, here, beside the charge and for the same reason: eviction
     // must never have to look at a payload again to know what it is giving
     // back. See LAST_VALUE_WINS.
-    [ENRICHMENT]: raw != null && typeof raw === "object" && LAST_VALUE_WINS.has(raw.hook_event_name),
+    [ENRICHMENT]: isEnrichment(raw),
   };
   events.push(evt);
   bufferedChars += evt[CHARS];

package/src/server/good-life-radio.mjs

@@ -26,7 +26,8 @@ function currentLiveVideo(html) {
 
 export async function fetchGoodLifeRadio({ fetchImpl } = {}) {
   const now = Date.now();
-  if (cache && now - cacheAt < cacheTtl) return cache;
+  // The stamp, not the value: a miss is remembered too, as null.
+  if (cacheAt && now - cacheAt < cacheTtl) return cache;
   if (inflight) return inflight;
   const get = fetchImpl ?? fetch;
   inflight = (async () => {

package/src/server/index.mjs

@@ -136,7 +136,7 @@ import { handleLanInvite, handleLanPeer, handleLanStatus, handleLanSync } from "
 // GET and POST /api/prefs — see prefs-routes.mjs.
 import { handlePrefsGiveBack, handlePrefsRead, handlePrefsWrite } from "./prefs-routes.mjs";
 import { MANIFEST_PATH, offerManifest } from "./app-manifest.mjs";
-import { historySnapshot, readProcesses, startSystemMetrics, systemSnapshot } from "./system-metrics.mjs";
+import { historySnapshot, processesReply, readProcesses, startSystemMetrics, systemSnapshot } from "./system-metrics.mjs";
 // How every route reads a body and answers, and the answer for one that threw
 // — see http-io.mjs. sendInternalError was exported from this file before it
 // moved, and still is.
@@ -238,6 +238,7 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
       host: req.headers.host,
       secFetchSite: req.headers["sec-fetch-site"],
       referer: req.headers.referer,
+      token: req.headers["x-ccdeck-token"],
     })) {
       return send(res, 403, { error: "cross-site request blocked" });
     }
@@ -309,7 +310,7 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
       // draws four columns and needs none of it, so on a deck where the modal
       // is never opened the argv is never read at all.
       const detail = url.searchParams.get("detail") === "1";
-      return guard(readProcesses(process.platform, detail).then(r => send(res, 200, { ok: true, ...r })), res);
+      return guard(readProcesses(process.platform, detail).then(r => send(res, 200, processesReply(r))), res);
     }
     // A day of minute buckets, which is far too much to ride along on
     // /api/system's three-second poll for a chart that is usually closed. Its

package/src/server/installer.mjs

@@ -106,21 +106,68 @@ export function hookCommand(installedHookPath, provider, node = process.execPath
   return `${q(node)} ${q(installedHookPath)} --provider ${q(provider)}`;
 }
 
-function isOurEntry(g) {
-  if (!g || typeof g !== "object") return false;
+function isMarked(g) {
   if (g[MARK_KEY] === true) return true;
   for (const k of LEGACY_MARKS) if (g[k] === true) return true;
-  const cmds = Array.isArray(g.hooks) ? g.hooks : [];
-  for (const h of cmds) {
-    const c = typeof h?.command === "string" ? h.command : "";
-    for (const dir of LEGACY_DIRS) {
-      if (c.includes(`.claude/${dir}/hook.js`) || c.includes(`.claude\\${dir}\\hook.js`)) return true;
-      if (c.includes(`.codex/${dir}/hook.js`) || c.includes(`.codex\\${dir}\\hook.js`)) return true;
-    }
+  return false;
+}
+
+/**
+ * Whether one command is our forwarder. In a group we marked, any path ending
+ * in one of our directories' hook.js — the config dir may be relocated and so
+ * not be called `.claude` at all. Anywhere else only the `.claude`/`.codex`
+ * spelling, which is what an entry from before the mark, or one written by
+ * hand, looks like.
+ */
+function isOurCommand(h, marked) {
+  const c = typeof h?.command === "string" ? h.command : "";
+  for (const dir of LEGACY_DIRS) {
+    if (c.includes(`.claude/${dir}/hook.js`) || c.includes(`.claude\\${dir}\\hook.js`)) return true;
+    if (c.includes(`.codex/${dir}/hook.js`) || c.includes(`.codex\\${dir}\\hook.js`)) return true;
+    if (marked && (c.includes(`/${dir}/hook.js`) || c.includes(`\\${dir}\\hook.js`))) return true;
   }
   return false;
 }
 
+/** What withoutOurCommands answers for a group with nothing left in it. */
+const DROP = Symbol("drop");
+
+/**
+ * One group with our forwarders taken out of it: `g` itself when nothing in it
+ * was ours, DROP when nothing is left, and otherwise a copy holding the rest
+ * with its matcher and without our marks.
+ *
+ * PER COMMAND, NOT PER GROUP (#1734). This used to decide for the whole group —
+ * marked, or one command naming our hook.js — and drop all of it. But the group
+ * we write has no matcher, and Claude Code's own hook editor files a new
+ * matcher-less hook into the first group for that event whose matcher is
+ * missing or empty, which on a machine with no hook of the user's own for that
+ * event is ours. The next start then rewrote settings.json without the user's
+ * sound or PreToolUse guard, and said nothing. Only our forwarder is ours.
+ *
+ * A marked group whose `hooks` is not a list is dropped, as it always was; an
+ * unmarked one is left exactly where it is, as it always was.
+ */
+function withoutOurCommands(g) {
+  if (!g || typeof g !== "object") return g;
+  const marked = isMarked(g);
+  if (!Array.isArray(g.hooks)) return marked ? DROP : g;
+  const kept = g.hooks.filter(h => !isOurCommand(h, marked));
+  if (!marked && kept.length === g.hooks.length) return g;
+  if (kept.length === 0) return DROP;
+  const rest = {};
+  for (const [k, v] of Object.entries(g)) {
+    if (k === MARK_KEY || LEGACY_MARKS.includes(k)) continue;
+    rest[k] = k === "hooks" ? kept : v;
+  }
+  return rest;
+}
+
+/** Whether a group holds anything of ours — a forwarder, or our mark. */
+function isOurEntry(g) {
+  return withoutOurCommands(g) !== g;
+}
+
 async function ensureDir(p) {
   if (!existsSync(p)) await mkdir(p, { recursive: true });
 }
@@ -207,7 +254,7 @@ function buildHookEntry(command) {
 
 function dedupeOurEntries(group) {
   if (!Array.isArray(group)) return [];
-  return group.filter(g => !isOurEntry(g));
+  return group.map(withoutOurCommands).filter(g => g !== DROP);
 }
 
 /**
@@ -422,8 +469,11 @@ export async function uninstallHooks({ provider = "claude", beforeWrite = null }
   if (!current?.hooks) return { ok: true, changed: false, provider, settingsPath: cfg.settingsPath };
   let changed = false;
   for (const evt of Object.keys(current.hooks)) {
-    const cleaned = dedupeOurEntries(current.hooks[evt]);
-    if (cleaned.length !== (current.hooks[evt]?.length ?? 0)) changed = true;
+    const was = current.hooks[evt];
+    const cleaned = dedupeOurEntries(was);
+    // A count alone no longer sees every change: a group that loses our
+    // forwarder but keeps the user's own hooks is still there, as a new object.
+    if (cleaned.length !== (was?.length ?? 0) || cleaned.some((g, i) => g !== was[i])) changed = true;
     if (cleaned.length === 0) delete current.hooks[evt];
     else current.hooks[evt] = cleaned;
   }

package/src/server/lan-beacon.mjs

@@ -305,10 +305,12 @@ export function createBeacon({
       announce(via === "tailscale" ? [rinfo.address] : []);
     }
     if (verdict !== "peer") {
-      // Another deck is using this one's key — see beaconVerdict. Reported
-      // rather than fixed here: this file carries packets, and choosing a new
-      // identity for the deck belongs to whoever stores it.
-      if (verdict === "id-clash") onIdClash?.();
+      // Another deck may be using this one's key — see beaconVerdict. Reported
+      // with where the beacon says that deck listens, rather than acted on
+      // here: this file carries packets, and finding out whether anything
+      // there holds the key, and choosing a new identity if it does, belong to
+      // whoever stores it.
+      if (verdict === "id-clash") onIdClash?.({ addr: rinfo.address, port: beacon.port });
       // A DECK NOBODY HAS ACCEPTED. It is not refused and not silently
       // dropped: it is a name and an address on the same network, which is a
       // row somebody can accept. Nothing is asked of it and nothing is

package/src/server/lan-call.mjs

@@ -200,6 +200,10 @@ export function connectToPeer({
       resolve({
         sock, key, sealed: !!chan,
         peerFp: theirFp, peerPub: theirPub, peerName: cleanName(msg.name, ""),
+        // The challenge the far end made for this connection, so a deck that
+        // reached its own key can ask its own listener whether it made it —
+        // see `issued` in lan-socket.mjs.
+        peerChallenge: theirChallenge,
         send: obj => sendFrame(sock, chan ? chan.wrap(obj) : obj),
         /** What a frame from the other end says — or null on a sealed
          *  connection when it does not open, which ends the connection: every

package/src/server/lan-dials.mjs

@@ -137,9 +137,18 @@ export function createDials() {
     rowAnswering: fp => [...manual.values()].find(p => learned.get(`${p.addr}:${p.port}`)?.fp === fp),
 
     /** A row put on for a paired deck that called in from it, on trial until a
-     *  round proves the address answers — see calledBack. */
+     *  round proves the address answers — see calledBack.
+     *
+     *  NEVER A ROW SOMEBODY TYPED (#1741). learnCaller asks for a trial
+     *  whenever `add` says yes, and `add` says yes for an address already on
+     *  the list and keeps a typed row typed — so a deck calling in from the
+     *  exact address somebody typed, before a round here had reached it, put
+     *  that row on trial and the next failed round took it away. It is not
+     *  the deck's to take away (#1674); who called from there is still worth
+     *  knowing, so the row reads as that deck. */
     trial(at, met) {
       learned.set(at, met);
+      if (manual.get(at)?.typed) return;
       calledBack.add(at);
     },
     /** A round reached `host:port` and `met` is who answered there. A