agent-dag 3.14.0 → 3.16.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-C7_uf54q.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DPOZaaRr.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "3.14.0",
+  "version": "3.16.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",
@@ -326,5 +336,15 @@
       "title": "🔕 The deck no longer puts anything in your settings.json",
       "body": "It used to add a hook there so Claude Code would play a sound when a turn ended. That entry is removed the first time you start this version, and any sound hook you wrote yourself is put back exactly where you had it. Nothing else in that file is touched. The deck makes the sound itself now — which is also why you finally hear one when a Codex turn ends, not just a Claude one."
     }
+  ],
+  "3.16.0": [
+    {
+      "title": "🤝 Pair two decks with one piece of text",
+      "body": "**Accounts ▸ Local network ▸ setup… ▸ make an invite.** Send the text however you already talk to them; they paste it and the two decks are paired. Nobody presses accept, and neither of you has to know which of your addresses the other can reach — the invite carries them all and their deck tries each one.\n\nDecks on the same router still find each other on their own and appear under **on this network right now**. An invite is for the case that does not work: another subnet, a VPN, a firewall.\n\nThe invite lasts 10 minutes and is used once. Anyone who gets hold of the text can pair with your deck until it runs out, so send it the way you would send anything else you would not want forwarded."
+    },
+    {
+      "title": "⚠️ Both machines have to be on this version",
+      "body": "The two decks no longer speak the old protocol, and there is no fallback: a 3.15 deck and a 3.16 deck cannot see each other at all. Update both.\n\nThe group passphrase is gone. If you had one set, that pairing is not carried over — make an invite and pair again. It was replaced because a passphrase that differs by one character produced a closed socket and no other symptom on either machine, and a secret is the one thing a panel must never print, so neither person could check theirs against the other's."
+    }
   ]
 }

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,60 @@ 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: "", secret: "", shared: [], manual: [], trusted: [], port: 0 }),
+});
+
+/** 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 : "",
+    // THIS DECK'S PRIVATE KEY, and the only secret this file has ever held —
+    // which is why the write below names a mode rather than taking the umask's.
+    // It is an X25519 private key in base64 pkcs8; anything else is replaced on
+    // the next start rather than refused, because a corrupt key is not a thing
+    // anybody can act on and refusing to start would take the feature away.
+    secret: typeof src.secret === "string" ? src.secret : "",
+    shared: strings(src.shared),
+    manual: strings(src.manual),
+    // THE DECKS SOMEBODY PRESSED ACCEPT ON. The public key is the load-bearing
+    // half: a fingerprint is a hash of it, so an entry without one cannot be
+    // checked against whatever answers at an address later, and an entry that
+    // cannot be checked is worse than no entry at all.
+    trusted: (Array.isArray(src.trusted) ? src.trusted : [])
+      .filter(t => t && typeof t.fp === "string" && typeof t.pub === "string")
+      .map(t => ({ fp: t.fp, pub: t.pub, name: typeof t.name === "string" ? t.name : "" })),
+    // The port this deck listened on last time, so an address somebody typed on
+    // the other machine still works after a restart. It asked the OS for a new
+    // one every start, which is invisible while broadcast works and is exactly
+    // what does not work in the case the address field exists for.
+    //
+    // A PREFERENCE, never a requirement: a port already taken falls through to
+    // an OS-chosen one and this is rewritten. 0 means "none yet".
+    port: Number.isInteger(src.port) && src.port > 0 && src.port < 65_536 ? src.port : 0,
+  };
+}
 
 /** Coerce whatever is on disk into a whole, known-shaped prefs object.
  *
@@ -60,7 +113,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 +153,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 +179,28 @@ 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 PRIVATE KEY 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. A page has no use for the key: what it needs is this deck's
+ * fingerprint, which is a hash of the PUBLIC half and comes from `/api/lan`.
+ *
+ * The pinned public keys of trusted decks go the same way, for a smaller
+ * reason: they are not secret, and they are forty characters of base64 that no
+ * page draws. What a page shows is a name and a fingerprint.
+ */
+export function publicPrefs(prefs) {
+  const p = normalise(prefs);
+  const { secret, trusted, ...lan } = p.lan;
+  return {
+    ...p,
+    lan: { ...lan, trusted: trusted.map(t => ({ fp: t.fp, name: t.name })) },
+  };
+}
+
 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,8 @@ 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 { 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 +3170,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 +3201,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 +3222,196 @@ 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 long-term key, kept so a restart is the same deck rather
+  // than a stranger to everybody who has paired with it. Written once, on the
+  // first start that has none. It IS a secret — prefs.json is 0600 for this.
+  // The port it actually got, kept so an address typed on the other machine
+  // still reaches this deck after it restarts. Written only when it differs
+  // from what is stored, so a normal start writes nothing.
+  onPort: async port => {
+    try { _prefs = await writePrefs({ lan: { port } }); }
+    catch { /* the address field still works this session; next start re-pins */ }
+  },
+  // A deck was accepted or unpaired. Written straight through, because the
+  // trusted list is the whole of who this deck will talk to and a list that
+  // only existed in memory would drop every pairing on restart.
+  onTrust: async trusted => {
+    try { _prefs = await writePrefs({ lan: { trusted } }); }
+    catch (err) { console.error(`${PRODUCT}: lan sync could not save the pairing:`, err?.message ?? err); }
+  },
+  // An address this deck must keep dialling: the far end of a pairing that
+  // happened over an invite. Kept in prefs, because setPeers replaces the dial
+  // list wholesale on every settings write and a row that lives only in memory
+  // is a pairing that goes one-way at the next restart.
+  onDial: async entry => {
+    try {
+      const manual = Array.isArray(_prefs?.lan?.manual) ? _prefs.lan.manual : [];
+      if (manual.includes(entry)) return;
+      _prefs = await writePrefs({ lan: { manual: [...manual, entry] } });
+    } catch { /* dialled this session; the next round re-adds it */ }
+  },
+  onIdentity: async secret => {
+    try {
+      _prefs = await writePrefs({ lan: { secret } });
+      // 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(),
+      secret: lan.secret || "",
+      shared: Array.isArray(lan.shared) ? lan.shared : [],
+      trusted: Array.isArray(lan.trusted) ? lan.trusted : [],
+      port: lan.port || 0,
+    });
+    // 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() });
+}
+
+/**
+ * Accept a deck, dismiss a request, or unpair one.
+ *
+ * ONE ROUTE, THREE VERBS, in the shape the accounts panel already uses for its
+ * own multi-verb writes. Each one takes a fingerprint and nothing else: the key
+ * being pinned comes from what this deck actually saw on the wire, never from
+ * the page, so a page cannot pair this deck with a key nobody has met.
+ */
+/**
+ * Make an invite, put one away, or join on somebody else's.
+ *
+ * The token is the secret and it is never stored: minted on request, held in
+ * memory until it expires or is used, and gone with the process. Nothing about
+ * it reaches prefs.json, so a deck that restarts is offering nothing rather
+ * than offering something its owner has forgotten they sent.
+ */
+async function handleLanInvite(req, res) {
+  const raw = await readBody(req).catch(() => null);
+  let body = null;
+  try { body = JSON.parse(raw ?? ""); } catch { /* handled below */ }
+  switch (body?.action) {
+    case "make": {
+      const made = lanEngine.invite();
+      if (!made) return send(res, 409, { ok: false, reason: "not_running" });
+      // AFTER the spread, not before: status carries its own `invite` — the
+      // token and its expiry, which is all a panel needs — and letting that
+      // overwrite this one dropped the address list the caller asked for.
+      return send(res, 200, { ok: true, ...lanEngine.status(), invite: made });
+    }
+    case "withdraw":
+      lanEngine.withdraw();
+      return send(res, 200, { ok: true, ...lanEngine.status() });
+    case "join": {
+      const out = await lanEngine.join(body.token);
+      if (!out.ok) return send(res, 200, { ok: false, ...out, ...lanEngine.status() });
+      return send(res, 200, { ok: true, ...out, ...lanEngine.status() });
+    }
+    default:
+      return send(res, 400, { ok: false, reason: "unknown_action" });
+  }
+}
+
+async function handleLanPeer(req, res) {
+  const raw = await readBody(req).catch(() => null);
+  let body = null;
+  try { body = JSON.parse(raw ?? ""); } catch { /* handled below */ }
+  const fp = body && typeof body.fp === "string" ? body.fp : null;
+  if (!fp) return send(res, 400, { ok: false, reason: "bad_request" });
+  switch (body.action) {
+    case "accept": {
+      const added = lanEngine.accept(fp);
+      if (!added) return send(res, 409, { ok: false, reason: "not_seen" });
+      // A deck we only HEARD is not pinned, it is dialled — see accept. The
+      // address has to reach prefs or the next write of the settings wipes it:
+      // setPeers replaces the dial list wholesale, on purpose, so an address
+      // that lives only in memory disappears the first time anything else is
+      // saved.
+      if (added.dialled) {
+        const entry = `${added.addr}:${added.port}`;
+        const manual = Array.isArray(_prefs?.lan?.manual) ? _prefs.lan.manual : [];
+        if (!manual.includes(entry)) {
+          try { _prefs = await writePrefs({ lan: { manual: [...manual, entry] } }); }
+          catch { /* it is dialled this session; the next accept re-adds it */ }
+        }
+      }
+      return send(res, 200, { ok: true, added, ...lanEngine.status() });
+    }
+    case "dismiss":
+      return send(res, 200, { ok: lanEngine.dismiss(fp), ...lanEngine.status() });
+    case "unpair":
+      return send(res, 200, { ok: lanEngine.unpair(fp), ...lanEngine.status() });
+    default:
+      return send(res, 400, { ok: false, reason: "unknown_action" });
+  }
+}
+
+/** 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 +5639,10 @@ 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 === "POST" && url.pathname === "/api/lan/peer")     return guard(handleLanPeer(req, res), res);
+    if (req.method === "POST" && url.pathname === "/api/lan/invite")   return guard(handleLanInvite(req, res), 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,