agent-dag 3.15.0 → 3.17.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-CbYzt04Y.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CqAgutJT.css">
+    <script type="module" crossorigin src="/assets/index-CSpWSOAU.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BwFExw1D.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "3.15.0",
+  "version": "3.17.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,12 @@
     "about a defect in the type, and the suite refuses both it and no space at",
     "all."
   ],
+  "3.17.0": [
+    {
+      "title": "🔔 Pairing is two presses",
+      "body": "When another deck asks to pair, the question now arrives **over the deck** rather than in a row three sections down a panel: its name, its address, the fingerprint to compare, **Accept** or **Decline**. Escape means later — the request stays in the panel until you answer it.\n\nThe rest is one list. Every deck you are paired with, every deck on the network, and every one you turned away, each a row with its state under the name and one verb at the end — and a deck that cannot be reached now reads differently from one that is fine. Saying no also reaches the other machine now, instead of leaving it waiting forever; you can take it back.\n\nThe dialog behind **setup** is down to the two things it is really about: what this deck is called, and which logins it offers."
+    }
+  ],
   "3.15.0": [
     {
       "title": "🔗 Decks on one network heal each other's dead logins",
@@ -336,5 +342,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/deck-prefs.mjs

@@ -54,7 +54,7 @@ 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: "" }),
+  lan: Object.freeze({ enabled: false, name: "", secret: "", shared: [], manual: [], trusted: [], port: 0 }),
 });
 
 /** The mode prefs.json is created with.
@@ -79,15 +79,29 @@ function normaliseLan(raw) {
   return {
     enabled: typeof src.enabled === "boolean" ? src.enabled : false,
     name: typeof src.name === "string" ? src.name : "",
-    passphrase: typeof src.passphrase === "string" ? src.passphrase : "",
+    // 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),
-    // 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 : "",
+    // 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,
   };
 }
 
@@ -168,18 +182,23 @@ export async function writePrefs(patch, home = claudeConfigDir(), deps = {}) {
 /**
  * The preferences as a PAGE may see them.
  *
- * The passphrase never leaves this process. `GET /api/prefs` is readable by
+ * 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 — so what goes out is whether one is set, not what it is.
+ * 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`.
  *
- * A boolean rather than a mask: `••••••••` in a field invites a page to send it
- * back, and then the dots are the passphrase.
+ * 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 { passphrase, ...lan } = p.lan;
-  return { ...p, lan: { ...lan, hasPassphrase: passphrase !== "" } };
+  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) {

package/src/server/index.mjs

@@ -7,7 +7,7 @@ import { createServer, request as httpRequest } from "node:http";
 import { readFile, stat, mkdir, open, truncate, readdir, unlink } from "node:fs/promises";
 import { existsSync, readFileSync, realpath as realpathCb, realpathSync } from "node:fs";
 import { extname, join, resolve, sep, dirname as pdirname } from "node:path";
-import { homedir } from "node:os";
+import { homedir, networkInterfaces } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname } from "node:path";
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
@@ -18,7 +18,8 @@ import { PRODUCT } from "./brand.mjs";
 import { createBlockNotifier } from "./block-notify.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 { PROBE_PS, localAliases, reachability, readProbe } from "./lan-reach.mjs";
+import { run } from "./exec.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";
@@ -3255,12 +3256,37 @@ const lanEngine = createEngine({
     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 => {
+  // 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 {
-      _prefs = await writePrefs({ lan: { deckId: id } });
+      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
@@ -3285,9 +3311,10 @@ async function applyLanPrefs() {
     await lanEngine.apply({
       enabled: !!lan.enabled,
       name: lan.name || defaultName(),
-      passphrase: lan.passphrase || "",
+      secret: lan.secret || "",
       shared: Array.isArray(lan.shared) ? lan.shared : [],
-      deckId: lan.deckId || "",
+      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.
@@ -3297,29 +3324,137 @@ async function applyLanPrefs() {
   }
 }
 
+// ── can other decks reach this one ──────────────────────────────────────────
+//
+// NEVER IN THE REQUEST. The panel polls this route, and the probe is a
+// PowerShell start-up — the better part of a second on a warm machine and
+// worse on a cold one. So the route answers with whatever the last probe said
+// and starts the next one behind it. The first poll after a deck starts
+// carries no verdict, which is correct rather than merely tolerable: at that
+// point the deck has not been listening long enough for an empty list to mean
+// anything either.
+//
+// STALE IS THE RIGHT DEFAULT HERE. What this measures — a network's category, a
+// firewall rule — changes when somebody changes it, which is a thing they do
+// while looking at the instructions this produced. Five minutes is far tighter
+// than that, and the panel's own reload picks up the change on the next poll.
+let reachSaid = null;
+let reachAt = 0;
+let reachBusy = false;
+const REACH_MS = 5 * 60_000;
+
+function refreshReach() {
+  if (reachBusy || process.platform !== "win32") return;
+  if (reachAt && Date.now() - reachAt < REACH_MS) return;
+  reachBusy = true;
+  run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", PROBE_PS], {
+    // The program path goes through the environment rather than into the
+    // script, so a path with a quote in it cannot close the string it sits in.
+    env: { ...process.env, CCDECK_EXE: process.execPath },
+    timeout: 25_000,
+  }).then(r => {
+    reachSaid = reachability({
+      platform: process.platform,
+      probe: r?.ok ? readProbe(r.stdout) : null,
+      aliases: localAliases(networkInterfaces()),
+      exePath: process.execPath,
+    });
+  }).catch(() => {
+    // A probe that did not run says nothing, which is the same answer as a
+    // machine this cannot speak about. It is never an error the panel shows:
+    // nobody asked for it.
+    reachSaid = null;
+  }).finally(() => {
+    reachAt = Date.now();
+    reachBusy = false;
+  });
+}
+
 /** 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() });
+  refreshReach();
+  return send(res, 200, { ok: true, ...lanEngine.status(), reach: reachSaid });
 }
 
 /**
- * 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.
+ * 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.
  */
-function handleLanSuggest(req, res) {
-  return send(res, 200, { ok: true, passphrase: suggestPassphrase() });
+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() });
+    // The undo for the one above. A deck that was told no stops asking; this is
+    // how somebody who changed their mind lets it ask again.
+    case "allow":
+      return send(res, 200, { ok: lanEngine.allow(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
@@ -5558,7 +5693,8 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
     // 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/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());