agent-dag 3.14.0 → 3.15.0

package/dist/web/index.html

@@ -40,8 +40,8 @@
         document.documentElement.setAttribute("data-theme", stored === "light" ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-CinWEMD2.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Xyt_GsRj.css">
+    <script type="module" crossorigin src="/assets/index-CbYzt04Y.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CqAgutJT.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "3.14.0",
+  "version": "3.15.0",
   "description": "Live deck of Claude Code and Codex agents — watch tool calls, token spend and every Claude Code subagent on one calm canvas. Run it with npx ccdeck.",
   "type": "module",
   "bin": {

package/release-notes.json

@@ -31,6 +31,16 @@
     "about a defect in the type, and the suite refuses both it and no space at",
     "all."
   ],
+  "3.15.0": [
+    {
+      "title": "🔗 Decks on one network heal each other's dead logins",
+      "body": "A login dies on the machine that has not used it while the same account keeps working on the machine that has. The fix was a blob copied out of one deck and pasted into another. Now: **Accounts ▸ Local network**, the same passphrase on each deck — it offers you six words — and they find each other and repair themselves.\n\nA deck only **adds** an account it does not have, or **replaces one it has proven dead** — proven by Anthropic refusing the token, not guessed. A credential that works is never touched. The passphrase is the only gate; a stranger on the same wifi sees that a deck exists and nothing else."
+    },
+    {
+      "title": "⚠️ What sharing a login actually means",
+      "body": "**A login you share is a live one, and it cannot be taken back.** Turning the switch off stops what has not happened yet; a credential that has left your machine is gone, and the only real revocation is signing in again at Anthropic — which ends the session everywhere at once.\n\nSharing a Claude account may also be against Anthropic's terms. Your call; the deck says it once and does not nag."
+    }
+  ],
   "3.14.0": [
     {
       "title": "📊 The machine comes back beside the list that covers it",

package/src/server/claude-accounts.mjs

@@ -464,6 +464,19 @@ async function readRoster(now, gen) {
       email:    acct.email ?? null,
       alias:    acct.alias ?? null,
       org:      acct.organizationName ?? null,
+      // The other half of an account's identity, and the reason a slot number
+      // is not one: claude-swap keys on `(email, organizationUuid)` — the same
+      // email under two orgs is two accounts on purpose — and assigns slots
+      // max+1 per store, so the account that is 4 here is 2 on another machine.
+      // Surfaced for LAN sync, which has to match accounts across two stores
+      // that grew in a different order.
+      orgUuid:  acct.organizationUuid ?? null,
+      // Whether CLAUDE-SWAP'S STORED COPY works — not whether the user is
+      // signed in. The two differ, and #721 is the whole argument: a
+      // `stale-copy` row means the live session is fine while the copy in the
+      // store is dead, and the copy is what a share would carry and what a
+      // peer's copy would heal. So both kinds of trouble read as not alive.
+      alive:    trouble == null,
       active:   String(seq.activeAccountNumber) === num,
       disabled: acct.disabled === true,
       lanes,

package/src/server/deck-prefs.mjs

@@ -50,7 +50,46 @@ export const prefsPath = (home = claudeConfigDir()) => join(prefsDir(home), "pre
  * release notes describe; a switch that quietly turned an existing feature off
  * on upgrade would be a worse surprise than the noise it is meant to stop.
  */
-export const DEFAULTS = Object.freeze({ notifications: true });
+export const DEFAULTS = Object.freeze({
+  notifications: true,
+  // LAN sync, off until somebody turns it on. `passphrase` is the only secret
+  // this file has ever held, which is why the write below now names a mode.
+  lan: Object.freeze({ enabled: false, name: "", passphrase: "", shared: [], manual: [], deckId: "" }),
+});
+
+/** The mode prefs.json is created with.
+ *
+ *  It held nothing but booleans until LAN sync, and a booleans file at the
+ *  umask default is unremarkable. A group passphrase is not: on a shared
+ *  machine the default mode hands it to every other account on the box, and
+ *  from it they can decrypt any credential that crosses the network.
+ *
+ *  Passed to `writeFile` rather than applied with a follow-up chmod, and the
+ *  difference is the whole point — claude-swap's transfer.py makes the same
+ *  argument at length: a write-then-chmod leaves the file readable for the
+ *  window between the two, which is exactly when a secret is in it. */
+export const PREFS_MODE = 0o600;
+
+/** One LAN section, coerced. Unknown keys dropped like everything else here,
+ *  and the two lists forced to arrays of strings — they arrive from a page and
+ *  are then compared against account keys and dialled as addresses. */
+function normaliseLan(raw) {
+  const src = raw && typeof raw === "object" ? raw : {};
+  const strings = v => (Array.isArray(v) ? v.filter(x => typeof x === "string") : []);
+  return {
+    enabled: typeof src.enabled === "boolean" ? src.enabled : false,
+    name: typeof src.name === "string" ? src.name : "",
+    passphrase: typeof src.passphrase === "string" ? src.passphrase : "",
+    shared: strings(src.shared),
+    manual: strings(src.manual),
+    // A PUBLIC identifier, not a key and not a secret: it is in every beacon
+    // this deck broadcasts, and what authenticates is the passphrase. It is
+    // persisted so a restarted deck is recognised as the same one — without
+    // that, every restart adds a row to every peer's list that will never
+    // answer again, and the list is a graveyard within an afternoon.
+    deckId: typeof src.deckId === "string" && /^[0-9a-f]{12}$/.test(src.deckId) ? src.deckId : "",
+  };
+}
 
 /** Coerce whatever is on disk into a whole, known-shaped prefs object.
  *
@@ -60,7 +99,10 @@ export const DEFAULTS = Object.freeze({ notifications: true });
  *  a setting nothing here can see, which reads as support and is not. */
 export function normalise(raw) {
   const src = raw && typeof raw === "object" ? raw : {};
-  return { notifications: typeof src.notifications === "boolean" ? src.notifications : DEFAULTS.notifications };
+  return {
+    notifications: typeof src.notifications === "boolean" ? src.notifications : DEFAULTS.notifications,
+    lan: normaliseLan(src.lan),
+  };
 }
 
 /** What is on disk, or the defaults. A corrupt or absent file is not an error
@@ -97,10 +139,15 @@ export async function writePrefs(patch, home = claudeConfigDir(), deps = {}) {
     // 500s through `guard`, and the notifications switch silently does not
     // stick. POSIX rename(2) has no such rule, which is why this shipped green.
     const mv = deps.rename ?? renameWithRetry;
-    const next = normalise({ ...(await readPrefs(home, deps)), ...patch });
+    const prev = await readPrefs(home, deps);
+    // The LAN section merges rather than replaces, so a page toggling the
+    // switch does not have to send the passphrase back to keep it — and so
+    // nothing has to send a secret it was never given.
+    const merged = { ...prev, ...patch, lan: { ...prev.lan, ...(patch?.lan ?? {}) } };
+    const next = normalise(merged);
     await mk(prefsDir(home), { recursive: true });
     const tmp = `${prefsPath(home)}.${process.pid}.tmp`;
-    await write(tmp, JSON.stringify(next, null, 2) + "\n", "utf8");
+    await write(tmp, JSON.stringify(next, null, 2) + "\n", { encoding: "utf8", mode: PREFS_MODE });
     await mv(tmp, prefsPath(home));
     return next;
   };
@@ -118,6 +165,23 @@ export async function writePrefs(patch, home = claudeConfigDir(), deps = {}) {
  * the person who wrote the launch script are not always the same person, and
  * only one of them is making a claim about the machine.
  */
+/**
+ * The preferences as a PAGE may see them.
+ *
+ * The passphrase never leaves this process. `GET /api/prefs` is readable by
+ * anything that can reach the loopback port — which is the whole point of the
+ * deck's own threat model, and is why the share envelope is not served there
+ * either — so what goes out is whether one is set, not what it is.
+ *
+ * A boolean rather than a mask: `••••••••` in a field invites a page to send it
+ * back, and then the dots are the passphrase.
+ */
+export function publicPrefs(prefs) {
+  const p = normalise(prefs);
+  const { passphrase, ...lan } = p.lan;
+  return { ...p, lan: { ...lan, hasPassphrase: passphrase !== "" } };
+}
+
 export function notificationsOn(prefs, env = process.env) {
   if (env[OFF_ENV] === "1") return false;
   return normalise(prefs).notifications;

package/src/server/index.mjs

@@ -16,7 +16,9 @@ import { claudeConfigDir } from "./claude-dir.mjs";
 import { CODEX_HOME, CODEX_SESSIONS_DIR, STOP, walkRolloutDays } from "./codex-dir.mjs";
 import { PRODUCT } from "./brand.mjs";
 import { createBlockNotifier } from "./block-notify.mjs";
-import { DEFAULTS as PREF_DEFAULTS, notificationsOn, notificationsVetoed, readPrefs, writePrefs } from "./deck-prefs.mjs";
+import { DEFAULTS as PREF_DEFAULTS, notificationsOn, notificationsVetoed, publicPrefs, readPrefs, writePrefs } from "./deck-prefs.mjs";
+import { createEngine, defaultName } from "./lan-engine.mjs";
+import { suggestPassphrase } from "./lan-sync.mjs";
 import { notify as osNotify } from "./browser-react.mjs";
 import { invokedName, renameNotice } from "./invoked-as.mjs";
 import { appendLogLine, codexCwdInWorkspace, electWriters, foldsCase, writesCodexLog } from "./log-writer.mjs";
@@ -3169,7 +3171,10 @@ function redactDeckToken(raw) {
  * same freshness every other cross-deck setting has.
  */
 let _prefs = { ...PREF_DEFAULTS };
-readPrefs().then(p => { _prefs = p; }).catch(() => {});
+// And LAN sync starts from the same read, so a deck that had it on comes back
+// with it on. `applyLanPrefs` is defined below — this runs after module
+// evaluation, which is what makes the forward reference fine.
+readPrefs().then(async p => { _prefs = p; await applyLanPrefs(); }).catch(() => {});
 
 const blockNotifier = createBlockNotifier({
   notify: osNotify,
@@ -3197,7 +3202,11 @@ const blockNotifier = createBlockNotifier({
 function prefsPayload() {
   return {
     ok: true,
-    prefs: _prefs,
+    // `publicPrefs`, never `_prefs`. This route answers anything that can reach
+    // the loopback port, and the LAN group passphrase is in the stored object —
+    // one field, and sending it here would put it in front of every page on the
+    // machine. What goes out is whether one is set.
+    prefs: publicPrefs(_prefs),
     notificationsAllowed: notificationsOn(_prefs),
     notificationsVetoed: notificationsVetoed(),
   };
@@ -3214,9 +3223,113 @@ async function handlePrefsWrite(req, res) {
   try { body = JSON.parse(raw ?? ""); } catch { /* handled below */ }
   if (!body || typeof body !== "object") return send(res, 400, { ok: false, reason: "bad_request" });
   _prefs = await writePrefs(body);
+  // The engine reads its settings from here rather than holding its own copy,
+  // so turning the switch off in the panel really does stop the sockets rather
+  // than only changing what the panel says.
+  await applyLanPrefs();
   return send(res, 200, prefsPayload());
 }
 
+// ── LAN sync ────────────────────────────────────────────────────────────────
+//
+// The engine is built once and told the settings; it opens and closes its own
+// sockets as those change. Nothing here touches a credential — see
+// lan-engine.mjs, which passes an opaque blob between two claude-swap commands.
+const lanEngine = createEngine({
+  readAccounts: async () => {
+    const { fetchClaudeAccounts } = await import("./claude-accounts.mjs");
+    return fetchClaudeAccounts();
+  },
+  exportAccount: async num => {
+    const { shareAccounts } = await import("./cswap-admin.mjs");
+    const out = await shareAccounts([String(num)]);
+    return out?.ok ? out.blob : null;
+  },
+  importAccount: async blob => {
+    const { importAccount } = await import("./cswap-admin.mjs");
+    // NO `force`, ever, and this is the line where that promise is kept. A
+    // plain import adds an account that is missing and replaces exactly one
+    // claude-swap has quarantined; it SKIPS one that is present and healthy.
+    // So a peer cannot overwrite a working credential of this deck's even by
+    // lying about its own, because the flag that would allow it is not passed.
+    const out = await importAccount(blob);
+    return !!out?.ok;
+  },
+  // The deck's own public id, kept so a restart is the same deck rather than a
+  // new row in every peer's list. Written once, on the first start that has
+  // none — not a secret, and in every beacon this deck sends.
+  onIdentity: async id => {
+    try {
+      _prefs = await writePrefs({ lan: { deckId: id } });
+      // AND PUT IT TO WORK. Writing it alone was not enough: a clash was
+      // detected, a new id was stored, and both decks kept broadcasting the old
+      // one — so they stayed invisible to each other with a correct file on
+      // disk. `apply` restarts only when the id it is holding differs from the
+      // one it is given, so this settles after one pass rather than looping.
+      await applyLanPrefs();
+    } catch { /* the next start picks it up; a shared id is the cost until then */ }
+  },
+  onError: (what, err) => {
+    // Reported, never thrown. A machine with no route, a firewall that refuses
+    // the bind, an interface that comes and goes with a VPN — none of them is a
+    // reason for the deck to fall over.
+    if (what !== "other-group") console.error(`${PRODUCT}: lan sync (${what}):`, err?.message ?? err);
+  },
+});
+
+/** Push whatever is in prefs at the engine. Called at boot and after every
+ *  write, so there is one source of truth and it is the file. */
+async function applyLanPrefs() {
+  const lan = _prefs?.lan ?? {};
+  try {
+    await lanEngine.apply({
+      enabled: !!lan.enabled,
+      name: lan.name || defaultName(),
+      passphrase: lan.passphrase || "",
+      shared: Array.isArray(lan.shared) ? lan.shared : [],
+      deckId: lan.deckId || "",
+    });
+    // Wholesale, so removing an address in the panel really stops it being
+    // dialled rather than only taking the row away.
+    lanEngine.setPeers(lan.manual);
+  } catch (err) {
+    console.error(`${PRODUCT}: lan sync could not start:`, err?.message ?? err);
+  }
+}
+
+/** What the panel draws: the switch, this deck's own name and address, and who
+ *  else is in the group. No passphrase, for the reason prefsPayload gives. */
+function handleLanStatus(req, res) {
+  return send(res, 200, { ok: true, ...lanEngine.status() });
+}
+
+/**
+ * A strong group passphrase, for the field to open with.
+ *
+ * THE WHOLE FEATURE'S SECURITY IS THIS STRING — groupKey scrypts it and
+ * everything else hangs off that — and until this route existed the field
+ * opened empty under a placeholder reading "the same words on every deck",
+ * which is an invitation to type something two people can both remember.
+ * suggestPassphrase has been written, documented and tested since the first
+ * commit of the feature and was reachable from nothing.
+ *
+ * Generated per request rather than folded into the status route, because the
+ * status route is polled every five seconds and a suggestion that changed
+ * under somebody's fingers while they read it out loud would be worse than no
+ * suggestion at all.
+ */
+function handleLanSuggest(req, res) {
+  return send(res, 200, { ok: true, passphrase: suggestPassphrase() });
+}
+
+/** Ask every peer now rather than at the next tick — the button beside the
+ *  list, for somebody who has just fixed a login on the other machine and does
+ *  not want to wait a minute to see it arrive. */
+async function handleLanSync(req, res) {
+  const done = await lanEngine.round();
+  return send(res, 200, { ok: true, done, ...lanEngine.status() });
+}
+
 function pushEvent(raw, source, opts = {}) {
   // First, before anything below can see it: the deck's own credential does not
   // belong in a store that is served without one. Every entry point to the
@@ -5444,6 +5557,9 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
     // Machine state, not session state: sampled on the server's own timer and
     // deliberately kept out of the event stream. See src/server/system-metrics.mjs.
     if (req.method === "GET"  && url.pathname === "/api/prefs")        return handlePrefsRead(req, res);
+    if (req.method === "GET"  && url.pathname === "/api/lan")          return handleLanStatus(req, res);
+    if (req.method === "GET"  && url.pathname === "/api/lan/passphrase") return handleLanSuggest(req, res);
+    if (req.method === "POST" && url.pathname === "/api/lan/sync")     return guard(handleLanSync(req, res), res);
     if (req.method === "POST" && url.pathname === "/api/prefs")        return guard(handlePrefsWrite(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/system")       return send(res, 200, systemSnapshot());
     // On demand only — the process list costs a subprocess on every platform,