@cello-protocol/daemon 0.0.227 → 0.0.229

package/dist/standing-receivers.d.ts

@@ -0,0 +1,319 @@
+/**
+ * CELLO Daemon — THE STANDING RECEIVER: THE NODE THAT IS ALWAYS LISTENING
+ *
+ * Split out of `session-node-manager.ts` by 037-SESSIONCORE. One pre-created node per agent, kept
+ * alive at all times and handed to the first inbound session — then immediately replaced, so there
+ * is always one waiting.
+ *
+ * ⚠️ **ITS GATER IS NOT OPEN, and this sentence used to say it was.** `DOD-M15-ASSIGN-1` closed
+ * exactly that: the gater admits NOBODY inbound until a session offer names the dialer, while
+ * leaving this node's own outbound errands open (`allowedPeerId: null` — see the construction
+ * below, which says the same thing in the imperative).
+ *
+ * The wrong version is called out rather than quietly corrected because of what believing it costs:
+ * a reader who thinks the gater is open reads an unnamed-dialer rejection as a BUG and opens it, or
+ * waves off the hardening as already done. It was inherited from the manager's own header, which is
+ * corrected in the same commit.
+ *
+ * Moved verbatim, comments included.
+ *
+ * ⚠️ ITS ABSENCE IS THE FIRST SUSPECT WHEN A LIVE SESSION FAILS. `standing_receiver_unavailable`,
+ * an empty counterparty peer id, `Invalid peer ID: ""` — all of them start here. The receiver is
+ * created when the agent is STARTED, not at daemon boot, so an agent that was never started has no
+ * receiver and nothing to hand an inbound session.
+ */
+import type { Logger } from "./types.js";
+import { NodeAutoNatService, type CelloNode, type IAutoNatService } from "@cello-protocol/transport";
+import { SessionConnectionGater } from "./session-connection-gater.js";
+import type { DaemonDatabase } from "./sqlcipher-db.js";
+import type { ISessionNodeFactory } from "./session-node-types.js";
+import { type SessionNodeConfig } from "./session-node-types.js";
+import type { SessionRecords } from "./session-records.js";
+import type { ParkRecovery } from "./park-recovery.js";
+/** What the standing receiver needs from the manager. */
+export interface StandingReceiverContext {
+    readonly logger: Logger;
+    readonly records: SessionRecords;
+    readonly park: ParkRecovery;
+    /**
+     * 055-ONDEMAND — has the session this offer was for actually started? Read when the abandoned-offer
+     * timer fires, so a slot taken for an offer that went nowhere is given back.
+     */
+    sessionIsLive(agentName: string, sessionIdHex: string): boolean;
+    /** 055-ONDEMAND — does any of this agent's live sessions hold a circuit right now? */
+    anyLiveSessionHoldsCircuit(agentName: string): boolean;
+    readonly factory: ISessionNodeFactory;
+    /** A function: the manager opens its database after construction. Re-exposed below as `#db`. */
+    db(): DaemonDatabase | null;
+    shuttingDown(): boolean;
+    sessionKey(agentName: string, sessionId: string): string;
+    /**
+     * ⚠️ THESE MAPS ARE SHARED BY REFERENCE, NOT OWNED HERE. The reservation watchdog, the relay
+     * paths and session creation all read them and all stayed behind, so giving this module its own
+     * copies would create two answers to "which agents have a receiver". Each is assigned exactly
+     * once, at construction, so there is one object and no divergence.
+     */
+    readonly standingReceivers: Map<string, {
+        node: CelloNode;
+        gater: SessionConnectionGater;
+        autoNat: NodeAutoNatService;
+        seed: Uint8Array;
+        relayPeerIds: string[];
+    }>;
+    readonly standingReceiverCreating: Set<string>;
+    readonly agentsWantingReceiver: Set<string>;
+    readonly standingReceiverRemoving: Set<string>;
+    readonly srReservationRetry: Map<string, {
+        attempts: number;
+        nextAt: number;
+        correlationId: string;
+        lastReason?: string;
+    }>;
+    readonly srLastRejectionReason: Map<string, string>;
+    readonly directoryRelayEndpoints: Map<string, Array<{
+        relayPeerId: string;
+        relayAddrs: string[];
+    }>>;
+    readonly srRetryDelaysMs: number[];
+    readonly srReservationTimeoutMs: number;
+    /** The AutoNAT prober list, injected by the composition root. */
+    autoNatProbers(): string[];
+    /**
+     * 055-ONDEMAND — tell a relay this agent is done with its slot. Best-effort: a release that
+     * could not be delivered costs a slot until its TTL and must never fail a seal.
+     */
+    tellRelayReleased(agentName: string, relayPeerId: string, node: CelloNode, correlationId: string): Promise<void>;
+    proveToRelay(agentName: string, circuitAddr: string, node: CelloNode, correlationId: string, surfaceAsReceiverRefusal: boolean): Promise<"proven" | "refused_try_another_relay" | "refused_this_agent" | "unavailable">;
+    reservationCircuitAddrs(agentName: string): {
+        addrs: string[];
+        relayPeerIds: string[];
+    };
+    authenticateStandingReceiver(agentName: string, node: CelloNode, relayPeerId: string, heldCircuitAddr: string, correlationId: string): Promise<void>;
+}
+export declare class StandingReceivers {
+    #private;
+    constructor(ctx: StandingReceiverContext);
+    /**
+     * 055-ONDEMAND — re-take a circuit on a node that already exists, for a live session that lost it.
+     *
+     * ⚠️ **IT PROVES OVER THE DELIVERY PATH TOO.** `DOD-M15-RELAYAUTH-1` applies identically here: a
+     * holder that has not proven key possession has its reservation revoked inside the relay's grace
+     * window, about fifteen seconds. The first version of the re-take called the low-level ask
+     * directly and skipped it, so a re-taken circuit would have been revoked almost immediately while
+     * the log said "granted" — the same defect this unit already fixed one function up.
+     */
+    retakeReservationOn(agentName: string, node: CelloNode, circuitAddr: string, correlationId: string): Promise<boolean>;
+    takeReservationForSession(agentName: string, circuitAddr: string, correlationId: string, 
+    /**
+     * ⚠️ **PRESENT ONLY ON THE OFFER PATH, AND THAT IS WHAT ARMS THE ABANDONED-OFFER RELEASE.**
+     *
+     * The first version reused `correlationId` for this, because the offer handler happens to pass
+     * the session id as its correlation id. Two meanings in one parameter is how a value ends up
+     * being trusted for something it was never chosen for: the watchdog's re-take passes a genuine
+     * correlation id, and it would have armed a timer keyed on a string that is not a session.
+     *
+     * Absent for the re-take path, which is by definition for a session that is already live.
+     */
+    offerSessionIdHex?: string): Promise<boolean>;
+    /**
+     * 055-ONDEMAND — **GIVE THIS SESSION'S SLOT BACK, FROM THE NODE THAT ACTUALLY HOLDS IT.**
+     *
+     * ⚠️ **THE FIRST VERSION LOOKED THE NODE UP BY AGENT NAME AND ALWAYS FOUND THE WRONG ONE.** When a
+     * session opens, the standing receiver is PROMOTED: `session-lifecycle` deletes it from
+     * `standingReceivers`, moves that exact node into `activeNodes`, and builds a fresh empty receiver
+     * behind it. So by seal time `standingReceivers.get(agentName)` is the new idle node, holding
+     * nothing — the release read `[]`, returned immediately, and told the relay nothing. The slot the
+     * offer took lived on the promoted node and died with it, invisible to the relay, held for the
+     * full TTL. **A release that always no-ops is worse than none: it logs success.**
+     *
+     * ⚠️ **AND THE CROSS-SESSION RECOMPUTE THE ORDER ASKED FOR IS UNNECESSARY, which is the good news
+     * in the correction.** libp2p's shared `reservationStore` is shared *within one node*. Each live
+     * session owns its OWN node, so sealing one cannot clear another session's refresh timers. There
+     * is nothing to recompute: this node is being torn down anyway, so tell its relays and drop its
+     * circuits. Re-deriving that removed a whole class of drift rather than managing it.
+     */
+    releaseSessionReservation(agentName: string, node: CelloNode, sessionId: string, correlationId: string): Promise<void>;
+    /**
+     * DOD-LOOP-1: ensure the given agent has a standing receiver node (idempotent). Created when an
+     * agent comes online (cello_start_agent) and replaced after it is handed off to a session. The
+     * `#standingReceiverCreating` guard prevents two concurrent ensure() calls (e.g. the
+     * cello_start_agent hook racing a consume-site retry) from building two nodes for one agent.
+     *
+     * M8B F14: a create failure no longer strands the agent deaf. Each ensure runs a BOUNDED
+     * retry loop (`standingReceiverRetryDelaysMs`, default 1s/5s/15s) — covering the fixed-port
+     * race where the consumed receiver still holds the port until its session node is torn down —
+     * and when every attempt fails, fires the alarm-worthy `session.standing_receiver.dead`
+     * (error level), distinct from the per-attempt `session.node.create.failed`. Re-arm is also
+     * kicked from destroySessionNode/retireSessionNode (the moment the port frees) and from the
+     * inbound accept path (ensure on demand), so one failure can never leave the agent deaf forever.
+     */
+    ensureStandingReceiver(agentName: string, correlationId?: string): Promise<void>;
+    /**
+     * DOD-M12B-SESSION-SEED-1 — build a revived session node that is REACHABLE, without ever hanging.
+     *
+     * MEASURED 2026-08-18, live, three ways:
+     *   - handed 2 relay addrs at once, no deadline:  `start()` never completes (10,002ms and counting)
+     *   - handed none:                                `start()` in 1ms, but NOBODY can dial the node —
+     *                                                 the counterparty's re-dial fails
+     *                                                 `counterparty_dial_failed` and every message in
+     *                                                 both directions has to go the relay park route
+     *   - this:                                       one candidate at a time, each raced against its
+     *                                                 own deadline, plain node as the floor
+     *
+     * The middle option is what shipped for one test run and it made the session half-dead: revived,
+     * `active`, and unreachable. The first is what shipped before that and it hung. Neither is a
+     * choice between "fast" and "reliable" — the per-candidate race is how `#startReceiverNode` has
+     * always done it, and it is the shape that works in production every day.
+     *
+     * A FAILED CANDIDATE IS TORN DOWN AT SETTLEMENT. The first version awaited `stop()` immediately
+     * and claimed that made seed reuse safe; it did not — `libp2p.stop()` returns at once unless the
+     * node is `'started'`, and during the timeout window it is `'starting'` (review HIGH-3, verified
+     * against libp2p 3.3.2). The teardown is now chained onto the candidate's OWN start promise, so it
+     * runs whenever that settles, however late.
+     *
+     * A BRIEF OVERLAP IS THEREFORE POSSIBLE and is stated rather than denied: a candidate that grants
+     * at 4s comes up on this session's peer id and is stopped immediately after. What is guaranteed is
+     * that it dies, not that it never lives. The receiver path avoids even that by minting a seed per
+     * candidate; here the identity is fixed, which is the whole point of a revival, so that option
+     * does not exist.
+     *
+     * The floor is a plain node: a session that is usable over the relay park route beats no session.
+     */
+    buildRevivedNode(sessionId: string, gater: SessionConnectionGater, seed: Uint8Array, candidateAddrs: string[], agentName: string): Promise<CelloNode>;
+    /**
+     * DOD-M15-RELAYONLY-1: build a transport node for THIS AGENT, with its privacy posture applied.
+     *
+     * ⚠️ THE CHOKE POINT FOR NODE CREATION, and it exists for the same reason as the one around
+     * `getStandingReceiverInfo`. Five call sites construct nodes; passing `relayOnly` at each would be
+     * a hand-kept list, and the SIXTH — added next month by someone who has never read this line —
+     * would build a node that hole-punches its way to a direct connection for an operator who asked
+     * never to be directly reachable. Here, a new caller inherits the posture instead of being told.
+     *
+     * `unknown` counts as ON, matching the publish and dial halves: a node that declines to hole-punch
+     * is reachable over the relay, while a disclosed address cannot be recalled.
+     */
+    createAgentNode(agentName: string, config: SessionNodeConfig): Promise<CelloNode>;
+    /**
+     * DOD-PARK-DRAIN-1 (review F6): why there is no standing-receiver node to dial from — named
+     * precisely, because `standing_receiver_unavailable` is the exit-point label that stood in for
+     * four different causes and misnamed this very incident 102 times.
+     *
+     * Only meaningful once `getStandingReceiverNode()` has returned null, which means NO agent on
+     * this daemon has a ready receiver — the dial node is not agent-scoped.
+     */
+    standingReceiverAbsenceReason(agentName: string): "daemon_shutting_down" | "standing_receiver_creating" | "agent_offline" | "no_standing_receiver";
+    getStandingReceiverInfo(agentName: string): {
+        peerId: string;
+        addrs: string[];
+    } | null;
+    /** DOD-LOOP-1: whether the given agent has a standing receiver ready (any agent if omitted). */
+    getStandingReceiverReady(agentName?: string): boolean;
+    /**
+     * The standing receiver's libp2p node — a general-purpose node usable for OUTBOUND dials that
+     * are not session-scoped (e.g. the content-park deposit/pull to the relay, MSG-001-3b). Its
+     * gater admits nobody INBOUND until a session names them (DOD-M15-ASSIGN-1), but leaves these
+     * outbound errands open. Returns null until the receiver is ready.
+     */
+    getStandingReceiverNode(agentName?: string): CelloNode | null;
+    /**
+     * DOD-M12B-RESERVATION-RETRY-1 — whether a NAT'd peer can actually DIAL this agent.
+     *
+     * `standing_receiver_ready` answers "is there a receiver?", which is true for a plain TCP node
+     * that no relay would give a circuit reservation to. Behind NAT that node is reachable by nobody,
+     * and the difference was visible only in the log — where it was visible 481 times and nobody
+     * acted. `"retrying"` and `"unreachable"` are the states an operator can do something about.
+     *
+     *   reserved    — holds a circuit reservation; a NAT'd peer can dial it.
+     *   retrying    — no reservation yet, still re-asking on a backoff.
+     *   unreachable — no circuit reservation and the automatic re-attempts are spent, so only peers
+     *                 that can connect DIRECTLY will get in. It is not permanent: a directory
+     *                 reconnect carrying a DIFFERENT relay pool re-arms the budget, because a relay we
+     *                 have never tried is new information.
+     *   absent      — no receiver at all (the agent is not online).
+     */
+    getStandingReceiverReachability(agentName: string): "reserved" | "ready" | "retrying" | "unreachable" | "absent";
+    /**
+     * CELLO-M7-TRANSPORT-001: the AutoNAT service wrapping the current standing
+     * receiver node, or null if the standing receiver is not ready. The composition
+     * root uses this as the daemon's runtime IAutoNatService — its getDialability()
+     * drives the SessionAssignment advertised address (AC-004/AC-019), and it is the
+     * source of the transport.autonat.result / transport.autonat.unavailable events.
+     */
+    getStandingReceiverAutoNat(): IAutoNatService | null;
+    /**
+     * Which peer this agent's standing receiver is currently admitting INBOUND — `null` for nobody.
+     *
+     * Read-only, and it answers a question the daemon otherwise cannot: *"whose dial would this
+     * receiver accept right now?"* The gate is narrowed and re-closed from several paths (an offer
+     * arrives, an assignment is refused, a session is promoted), and until now the only way to know
+     * where it had ended up was to reproduce the sequence in your head.
+     *
+     * Added for `DOD-M15-RESPONDER-VERIFY-1`, where a refusal for one session was closing the gate a
+     * DIFFERENT session had narrowed — a defect with no observable symptom short of the second
+     * session's initiator being refused with "nothing invited it".
+     */
+    getStandingReceiverAllowedPeer(agentName: string): string | null;
+    /**
+     * DOD-M15-ASSIGN-1 — name the one peer allowed to dial this agent's standing receiver, at the
+     * moment the directory's `session_offer` says who is coming.
+     *
+     * This is what makes the receiver's deny-by-default safe. The offer names
+     * `initiator_session_peer_id`, and the responder answers it by advertising its OWN address in
+     * `session_offer_accept`. Narrowing here — BEFORE that answer goes out — means the door opens to
+     * exactly one peer at the same instant the address that reaches them is published, and never
+     * before. The initiator cannot know where to dial until the accept it triggers has been sent.
+     *
+     * Returns WHICH failure it was, never a bare false (review F6). The caller reports a distinct
+     * reason per cause: "no receiver" and "the directory named nobody" are different subsystems, and
+     * collapsing them sent the operator to the directory for a local problem. This method never
+     * widens the gate to compensate.
+     *
+     * Narrows INBOUND ONLY. The receiver is still the daemon's general-purpose dialer at this point
+     * — no assignment exists yet — so revoking its outbound latitude here would break content
+     * parking and restart-seal submission (review F2).
+     */
+    admitOfferedDialer(agentName: string, initiatorSessionPeerId: string, sessionIdHex: string): "narrowed" | "no_receiver" | "no_peer_named";
+    /**
+     * What the UNSIGNED offer claimed, so the SIGNED assignment can be checked against it.
+     *
+     * DOD-M15-OFFER-SIGNED-1. Decision 2 rules that the listening socket is "gated on the
+     * assignment", and the gate is narrowed from `session_offer` — a frame carrying no signature —
+     * because that is the only thing that arrives early enough. Timing forced the offer; it does not
+     * excuse trusting it.
+     *
+     * Keeping what the offer said turns the two frames into a CHECK ON EACH OTHER. The assignment is
+     * FROST-signed by the initiator's own threshold group, which no single directory can produce, and
+     * it names the same peer id. A directory that says one peer in the offer and another in the
+     * assignment is naming two different dialers for one session — which a truthful directory never
+     * does, and which is exactly the move a compromised one would make to slip a peer past the gate
+     * before the signed document arrives.
+     */
+    getOfferedDialer(agentName: string, sessionIdHex: string): string | null;
+    /** Forget the offered dialer for ONE session — called on BOTH the claim and the refusal paths. */
+    clearOfferedDialer(agentName: string, sessionIdHex: string): void;
+    /**
+     * RE-CLOSE the standing receiver — but ONLY if this session is still the one holding it.
+     *
+     * DOD-M15-OFFER-SIGNED-1 review F4, then N1. The first version closed the gate unconditionally,
+     * and that was worse than the defect it fixed: an agent has ONE standing receiver with ONE allowed
+     * peer, so a refusal for session P closed the gate that offer Q had narrowed. Q's initiator —
+     * invited, legitimate — was then refused with *"nothing invited it"*, which this daemon had.
+     *
+     * That is the same cross-session interference F1 was written to remove, moved one method along,
+     * and triggerable the same way: one bogus offer/assignment pair collapses a concurrent real
+     * session.
+     *
+     * So the gate is closed only when it still names the peer THIS session opened it to. If a later
+     * offer has already re-narrowed it, that offer owns the receiver and its narrowing stands.
+     *
+     * NO EVICTION SWEEP, deliberately (N4). The sweep evicts by "not the allowed peer", and
+     * `getConnections()` returns OUTBOUND connections too — including the content-park and
+     * restart-seal dials this node makes as the daemon's general-purpose dialer, whose targets are on
+     * no allowlist by construction. Sweeping here hung those up, and the failure surfaced as
+     * `relay_unavailable`: a transport label for a local decision, which is the exact substitution
+     * that comment was written to prevent. The load-bearing control is `DOD-M15-FRAME-1`'s frame gate,
+     * which refuses what an unauthorised peer sends; closing the door is enough here.
+     */
+    revokeOfferedDialer(agentName: string, sessionIdHex: string, offeredPeerId: string | null): void;
+}
+//# sourceMappingURL=standing-receivers.d.ts.map

package/dist/standing-receivers.d.ts.map

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