@cello-protocol/daemon 0.0.202 → 0.0.204

package/dist/trust-signal-pickup-listener.js

@@ -0,0 +1,48 @@
+/**
+ * Build the registrar.
+ *
+ * `getHandler` is resolved at FRAME time, not at registration time: the daemon builds its signaling
+ * wiring before the inbound-session handlers exist, so capturing the handler when the listener is
+ * registered would bind whatever was there at boot — which for this frame type is nothing.
+ */
+export function createPickupListenerRegistrar(getHandler) {
+    return (signaling, agentName, agentKeyProvider, origin) => {
+        // WHY IN-FLIGHT WORK IS TRACKED RATHER THAN FLOATED AND FORGOTTEN.
+        //
+        // A visiting connection is transient: `openVisitingConnection`'s caller stops it the moment the
+        // session handoff finishes. The handler is asynchronous — it opens the seal, decodes, writes to
+        // the wallet, and only THEN acks — so a teardown can win the race and the ACK never lands. The
+        // signal itself is safe (the wallet write already happened and is content-addressed), but the
+        // directory keeps the row and re-sends the same pickup on every future visit, and the log names
+        // the failed send rather than the teardown that caused it.
+        //
+        // It also matters for what comes next: the fan-out closes each visiting connection on a terminal
+        // end-of-drain frame or a bounded ceiling, and a ceiling that fires mid-handler would truncate
+        // the drain the terminal frame exists to complete. Tracked here so that comes for free.
+        const inFlight = new Set();
+        signaling.registerInboundHandler((frame) => {
+            if (frame["type"] !== "trust_signal_pickup")
+                return;
+            // `signaling` is the stream the frame ARRIVED on, and that is what the handler ACKs down.
+            // Acking a visiting node's pickup down the home stream would leave the visited node's row
+            // unacked forever — re-sent on every visit, which is this bug wearing a different hat.
+            const p = getHandler()(frame, agentKeyProvider, signaling, agentName, origin)
+                .catch(() => { })
+                .finally(() => { inFlight.delete(p); });
+            inFlight.add(p);
+        });
+        return {
+            settle: async (timeoutMs) => {
+                if (inFlight.size === 0)
+                    return;
+                // BOUNDED. A handler wedged on a slow database must delay a teardown, never prevent one —
+                // an unbounded wait here would turn a stuck pickup into a stuck session close.
+                await Promise.race([
+                    Promise.allSettled([...inFlight]),
+                    new Promise((r) => setTimeout(r, timeoutMs)),
+                ]);
+            },
+        };
+    };
+}
+//# sourceMappingURL=trust-signal-pickup-listener.js.map

package/dist/trust-signal-pickup-listener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust-signal-pickup-listener.js","sourceRoot":"","sources":["../src/trust-signal-pickup-listener.ts"],"names":[],"mappings":"AA6CA;;;;;;GAMG;AACH,MAAM,UAAU,6BAA6B,CAC3C,UAA0C;IAE1C,OAAO,CAAC,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,EAAE,EAAE;QACxD,mEAAmE;QACnE,EAAE;QACF,gGAAgG;QAChG,gGAAgG;QAChG,+FAA+F;QAC/F,8FAA8F;QAC9F,gGAAgG;QAChG,2DAA2D;QAC3D,EAAE;QACF,iGAAiG;QACjG,+FAA+F;QAC/F,wFAAwF;QACxF,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAiB,CAAC;QAC1C,SAAS,CAAC,sBAAsB,CAAC,CAAC,KAAK,EAAE,EAAE;YACzC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,qBAAqB;gBAAE,OAAO;YACpD,0FAA0F;YAC1F,0FAA0F;YAC1F,uFAAuF;YACvF,MAAM,CAAC,GAAG,UAAU,EAAE,CAAC,KAAgC,EAAE,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC;iBACrG,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;iBACf,OAAO,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1C,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QACH,OAAO;YACL,MAAM,EAAE,KAAK,EAAE,SAAiB,EAAE,EAAE;gBAClC,IAAI,QAAQ,CAAC,IAAI,KAAK,CAAC;oBAAE,OAAO;gBAChC,0FAA0F;gBAC1F,+EAA+E;gBAC/E,MAAM,OAAO,CAAC,IAAI,CAAC;oBACjB,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC;oBACjC,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;iBAC7C,CAAC,CAAC;YACL,CAAC;SACF,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/dist/trust-signal-sweep.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Collecting trust signals parked at nodes this daemon is not connected to.
+ *
+ * ─── WHY A SWEEP IS NEEDED AT ALL ──────────────────────────────────────────────────────────────
+ *
+ * `pickup_queue` is node-local by design and does NOT replicate, so a signal delivered to one
+ * directory is collectable only from that directory. The one thing that collects it is a stream
+ * AUTHENTICATING there, because the drain runs on auth. An agent connects to a single directory —
+ * chosen at random on every start — so a signal parked anywhere else simply waited.
+ *
+ * C1 made a visiting connection able to receive pickups at all. This makes it deterministic rather
+ * than incidental: without it, collection happens only if you happen to start a session with
+ * someone who lives on that node.
+ *
+ * ─── WHAT THIS DELIBERATELY IS NOT ─────────────────────────────────────────────────────────────
+ *
+ * Not on the login path. The home stream drains inline on its own auth, as it always has; this runs
+ * in the background afterwards. The signaling wait is already the reason bootstrap needed a fast
+ * probe, and n round trips added to it would be felt on every start for a benefit that is never
+ * urgent — a signal that has waited for a directory to be visited can wait another few seconds.
+ *
+ * Not a node list. The roster comes from the signed manifest the daemon already polls, so a fleet
+ * of five sweeps five with no code change.
+ */
+import type { KeyProvider } from "@cello-protocol/crypto";
+import type { Logger } from "./types.js";
+import type { ConsortiumEndpoint } from "./directory-bootstrap.js";
+/** What a sweep found, per node. Never collapsed into a single boolean — see `unreachable`. */
+export interface SweepResult {
+    /** Nodes that answered and said their drain was finished. */
+    visited: string[];
+    /** Nodes that could not be dialled at all. */
+    unreachable: string[];
+    /** Nodes that answered but never said they were finished — we hit the ceiling instead. */
+    incomplete: string[];
+    /** True when the manifest could not be resolved, so we do not know who to ask. */
+    rosterUnavailable: boolean;
+}
+export interface TrustSignalSweepDeps {
+    logger: Logger;
+    resolveConsortiumRoster: () => Promise<ConsortiumEndpoint[] | null>;
+    /**
+     * Nodes the manifest declares that could NOT be resolved this sweep.
+     *
+     * Without this the `unreachable` bucket can never fill, because the roster is already the
+     * REACHABLE SUBSET — `manifestNodesToEndpoints` drops a node whose /bootstrap probe failed. A
+     * dead node therefore appeared in no bucket at all and the sweep reported "visited 2,
+     * unreachable 0" for a three-node fleet, which is exactly the false negative the order forbids:
+     * the operator is told nothing is waiting when nobody looked.
+     */
+    getUnresolvedNodes?: () => ReadonlyArray<{
+        nodeId: string;
+        reason: string;
+    }>;
+    openVisitingConnection: (agentName: string, agentKeyProvider: KeyProvider, agentPubkeyHex: string, endpoint: {
+        peerId: string;
+        multiaddr: string;
+    }, correlationId: string, nodeId: string) => {
+        mgr: {
+            registerInboundHandler: (h: (f: Record<string, unknown>) => void) => void;
+            /** "connected" once the stream is authenticated; the manager connects asynchronously. */
+            readonly status?: string;
+        };
+        stop: (reason: string) => Promise<void>;
+    };
+    /** How long to wait for a node's end-of-drain frame before closing anyway. */
+    ceilingMs?: number;
+}
+export type TrustSignalSweep = (agentName: string, agentKeyProvider: KeyProvider, agentPubkeyHex: string, 
+/**
+ * The node this daemon is already connected to, skipped because its drain ran on its own auth.
+ *
+ * Optional because the caller does not always know it. When it is unknown every node is visited,
+ * including home — which costs one extra connection whose drain immediately reports nothing left,
+ * not a wrong answer. A wasted round trip in the background beats guessing which node to skip.
+ */
+homeNodeId?: string) => Promise<SweepResult>;
+export declare function createTrustSignalSweep(deps: TrustSignalSweepDeps): TrustSignalSweep;
+//# sourceMappingURL=trust-signal-sweep.d.ts.map

package/dist/trust-signal-sweep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust-signal-sweep.d.ts","sourceRoot":"","sources":["../src/trust-signal-sweep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE,+FAA+F;AAC/F,MAAM,WAAW,WAAW;IAC1B,6DAA6D;IAC7D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,8CAA8C;IAC9C,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,0FAA0F;IAC1F,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,kFAAkF;IAClF,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,uBAAuB,EAAE,MAAM,OAAO,CAAC,kBAAkB,EAAE,GAAG,IAAI,CAAC,CAAC;IACpE;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,MAAM,aAAa,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,sBAAsB,EAAE,CACtB,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,WAAW,EAC7B,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAC/C,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,KACX;QACH,GAAG,EAAE;YACH,sBAAsB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,KAAK,IAAI,CAAC;YAC1E,yFAAyF;YACzF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;SAC1B,CAAC;QACF,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KACzC,CAAC;IACF,8EAA8E;IAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,gBAAgB,GAAG,CAC7B,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,WAAW,EAC7B,cAAc,EAAE,MAAM;AACtB;;;;;;GAMG;AACH,UAAU,CAAC,EAAE,MAAM,KAChB,OAAO,CAAC,WAAW,CAAC,CAAC;AAE1B,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,gBAAgB,CAiInF"}

package/dist/trust-signal-sweep.js

@@ -0,0 +1,123 @@
+import { extractErrorMessage } from "./error-message.js";
+export function createTrustSignalSweep(deps) {
+    const { logger, resolveConsortiumRoster, openVisitingConnection, getUnresolvedNodes } = deps;
+    const ceilingMs = deps.ceilingMs ?? 10_000;
+    // One sweep per agent at a time. `onConnected` fires on every reconnect, so a flapping stream
+    // would otherwise stack sweeps, each holding up to N authenticated visiting streams and
+    // re-triggering every node's drain. Duplicate delivery is safe — the wallet write is
+    // content-addressed and the drain deletes only on ACK — so this is load, not corruption, but it
+    // is load that arrives exactly when the network is already struggling.
+    const inFlight = new Set();
+    return async (agentName, agentKeyProvider, agentPubkeyHex, homeNodeId) => {
+        if (inFlight.has(agentName)) {
+            logger.info("trust_signal.sweep.already_running", { agentName });
+            return { visited: [], unreachable: [], incomplete: [], rosterUnavailable: false };
+        }
+        inFlight.add(agentName);
+        try {
+            return await run(agentName, agentKeyProvider, agentPubkeyHex, homeNodeId);
+        }
+        finally {
+            inFlight.delete(agentName);
+        }
+    };
+    async function run(agentName, agentKeyProvider, agentPubkeyHex, homeNodeId) {
+        const result = { visited: [], unreachable: [], incomplete: [], rosterUnavailable: false };
+        // Declared-but-unresolvable nodes, named BEFORE any dialling. These never reach the loop below
+        // because the roster excludes them, and saying nothing about them is how one dead node makes
+        // "nothing waiting" look true.
+        for (const n of getUnresolvedNodes?.() ?? []) {
+            if (n.nodeId === homeNodeId)
+                continue;
+            result.unreachable.push(n.nodeId);
+            logger.warn("trust_signal.sweep.node_unreachable", { agentName, node: n.nodeId, reason: n.reason });
+        }
+        const roster = await resolveConsortiumRoster();
+        if (!roster) {
+            // NOT the same as "nobody had anything". We do not know who to ask, and saying nothing was
+            // waiting would be a claim we cannot support.
+            result.rosterUnavailable = true;
+            logger.warn("trust_signal.sweep.roster_unavailable", { agentName });
+            return result;
+        }
+        // Skip home when we know it: its drain already ran on this stream's own auth, so visiting it
+        // would open a second authenticated connection to a node we are already on, for nothing.
+        const targets = homeNodeId ? roster.filter((n) => n.nodeId !== homeNodeId) : roster;
+        if (targets.length === 0)
+            return result;
+        for (const node of targets) {
+            const correlationId = `sweep-${agentName}-${node.nodeId}-${Date.now()}`;
+            let conn;
+            try {
+                conn = openVisitingConnection(agentName, agentKeyProvider, agentPubkeyHex, { peerId: node.peerId, multiaddr: node.multiaddr }, correlationId, node.nodeId);
+            }
+            catch (err) {
+                // openVisitingConnection connects ASYNCHRONOUSLY, so in practice it does not throw on a
+                // dial failure — that case is caught after the ceiling instead. This catches a synchronous
+                // fault while it wires the connection up, where `conn` is undefined and there is nothing to
+                // stop. One node failing must never end the sweep.
+                result.unreachable.push(node.nodeId);
+                logger.warn("trust_signal.sweep.node_unreachable", { agentName, node: node.nodeId, reason: extractErrorMessage(err) });
+                continue;
+            }
+            // try/finally, because the teardown is not optional. A throw between here and `stop()` would
+            // leave an AUTHENTICATED visiting connection open — and the order names the consequence
+            // directly: the directory drains its durable notification queue down any such stream, which
+            // is a bug this connection type has already caused once.
+            try {
+                // Register BEFORE the promise, so a throw here cannot reject it and skip the teardown.
+                let onComplete;
+                conn.mgr.registerInboundHandler((frame) => {
+                    if (frame["type"] !== "trust_signal_drain_complete")
+                        return;
+                    onComplete?.();
+                });
+                // Wait for the node to say the drain is finished — or give up at the ceiling.
+                //
+                // The terminal frame is what makes this correct: a timer alone truncates a slow drain and
+                // re-drops the remainder on the next sweep, forever, because the directory deletes on ACK
+                // and an un-acked row simply comes back. The ceiling is the backstop for a node that never
+                // sends one, including any directory older than that change.
+                const completed = await new Promise((resolve) => {
+                    const timer = setTimeout(() => resolve(false), ceilingMs);
+                    // Do not hold the process open waiting on a node that has gone quiet.
+                    timer.unref?.();
+                    onComplete = () => { clearTimeout(timer); resolve(true); };
+                });
+                if (completed)
+                    result.visited.push(node.nodeId);
+                else if (conn.mgr.status !== undefined && conn.mgr.status !== "connected") {
+                    // NEVER CONNECTED, so this is a transport failure and not a slow drain. Filing it as
+                    // `incomplete` would name the directory's drain for something that is the network —
+                    // an exit-point label standing in for the real cause, which is the reading an operator
+                    // would then act on.
+                    result.unreachable.push(node.nodeId);
+                    logger.warn("trust_signal.sweep.node_unreachable", {
+                        agentName, node: node.nodeId, reason: "never_connected", ceilingMs,
+                    });
+                }
+                else {
+                    // Connected and answering, but never said it was done. We may have collected everything
+                    // or only part of it and cannot tell — a different answer from a clean sweep, recorded
+                    // as one.
+                    result.incomplete.push(node.nodeId);
+                    logger.warn("trust_signal.sweep.no_terminal_frame", { agentName, node: node.nodeId, ceilingMs });
+                }
+            }
+            finally {
+                // `stop` awaits any in-flight pickup handler before tearing the stream down (C1 review), so
+                // a signal still being opened and stored is not cut off by this close.
+                await conn.stop("sweep_finished");
+            }
+        }
+        logger.info("trust_signal.sweep.finished", {
+            agentName,
+            visited: result.visited.length,
+            unreachable: result.unreachable.length,
+            incomplete: result.incomplete.length,
+        });
+        return result;
+    }
+    ;
+}
+//# sourceMappingURL=trust-signal-sweep.js.map

package/dist/trust-signal-sweep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust-signal-sweep.js","sourceRoot":"","sources":["../src/trust-signal-sweep.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cello-protocol/daemon",
-  "version": "0.0.202",
+  "version": "0.0.204",
   "private": false,
   "type": "module",
   "engines": {
@@ -35,10 +35,10 @@
     "@signalapp/sqlcipher": "^3.3.5",
     "cbor-x": "^1.6.0",
     "it-length-prefixed": "^10.0.1",
-    "@cello-protocol/crypto": "0.0.78",
-    "@cello-protocol/gateway": "0.0.62",
-    "@cello-protocol/protocol-types": "0.0.82",
-    "@cello-protocol/transport": "0.0.84"
+    "@cello-protocol/gateway": "0.0.64",
+    "@cello-protocol/crypto": "0.0.80",
+    "@cello-protocol/transport": "0.0.86",
+    "@cello-protocol/protocol-types": "0.0.84"
   },
   "devDependencies": {
     "@types/node": "^25.6.2",