@cello-protocol/daemon 0.0.227 → 0.0.229

package/dist/directory-bootstrap.d.ts

@@ -0,0 +1,310 @@
+/**
+ * Directory endpoint bootstrap for the daemon.
+ *
+ * The logic lives here, not in the adapter: the daemon must not depend on the
+ * adapter, which sits ABOVE it as a thin IPC proxy.
+ *
+ * Mechanism:
+ *   1. resolveDirectoryUrl(env): CELLO_DIRECTORY_URL or a random bundled endpoint.
+ *   2. GET ${url}/bootstrap → { multiaddr } containing "/p2p/<peerId>".
+ *   3. The peer ID is the segment after the final "/p2p/" in the multiaddr.
+ *
+ * The resolver caches the first successful resolution and re-attempts on each
+ * connect until it succeeds, so a daemon that starts before the directory is
+ * reachable will connect once the bootstrap endpoint comes up (the transport
+ * SignalingManager retries connect()).
+ */
+import type { ConsortiumNode } from "@cello-protocol/protocol-types";
+import type { DirectoryEndpoint } from "./signaling-connect.js";
+import type { Logger } from "./types.js";
+/**
+ * Production directory HTTP endpoint — the cold-boot fallback when CELLO_DIRECTORY_URL is unset.
+ *
+ * THIS MUST BE ONE OF THE `endpoint` VALUES IN THE BUNDLED MANIFEST, byte for byte. `buildManifestDeps`
+ * loads the bundled roster only when the resolved directory URL matches a node in it, and otherwise
+ * falls through to the pre-roster path with NO step-6 directory authentication — so a value that
+ * merely reaches the same machine, such as a DNS name for the same host, silently disables the
+ * defense against a MITM redirecting /bootstrap to a rogue directory. It fails open and quietly,
+ * which is why the requirement is stated here rather than left to be rediscovered. That the match
+ * is byte-exact and the miss is silent is `DOD-M15-STEP6-REPLAY-1` — tracked, not overlooked; the
+ * TLS half that made a single bundled name possible at all is `DOD-M15-BOOTSTRAP-TLS-1`.
+ *
+ * A NAME as of 2026-09-10, and the condition the previous comment set is exactly what changed: it
+ * said this "cannot be this constant until the manifest carries names", and the manifest now carries
+ * names. Every node sits behind its own regional load balancer terminating TLS, and the bundled
+ * roster moved to `https://directory-<region>.cello.mygentic.ai` in the same change. The two are
+ * only ever correct together.
+ *
+ * No port: 443, and the balancer's URL map routes /bootstrap, /manifest, /health, /agent-lookup and
+ * /registry to the node's HTTP listener while everything else — the libp2p WebSocket upgrade — goes
+ * to the protocol listener. One port now serves what needed two.
+ */
+export declare const PRODUCTION_DIRECTORY_URL = "https://directory-use1.cello.mygentic.ai";
+/**
+ * The bundled manifest's endpoint list, used by resolveDirectoryUrl to distribute cold-boot
+ * clients across the consortium instead of always landing on the same node.
+ *
+ * Import is lazy (inside the function) to avoid a circular dependency with bundled-consortium-manifest.
+ * Extracted as a separate export for testing.
+ */
+export declare function pickRandomBundledEndpoint(nodes: ReadonlyArray<Record<string, unknown>>): string;
+/**
+ * Resolve the directory URL from the environment, falling back to a RANDOMLY SELECTED
+ * bundled manifest endpoint when CELLO_DIRECTORY_URL is not set.
+ *
+ * Random, not fixed: every fresh daemon picks a different consortium node. Without this
+ * all clients land on the same node (whichever `PRODUCTION_DIRECTORY_URL` names), and the
+ * other nodes only ever appear as failover. That was fine with one user; it does not scale.
+ *
+ * The random pick changes on every process start. Daemons that are already running and have
+ * established a directory connection are unaffected — they stay connected to their current node
+ * and only re-pick on the next login/restart.
+ */
+export declare function resolveDirectoryUrl(env?: Record<string, string | undefined>): string;
+/**
+ * Failure class of a /bootstrap probe. DNS-INCIDENT R3 (2026-07-24): a blanket
+ * `catch { return null }` collapsed every distinct failure into one indistinguishable
+ * `unresolved` warning, so a machine-wide negative-DNS-cache outage (all names
+ * fail getaddrinfo, servers fully healthy) logged identically to a real server
+ * outage. `reason: "dns_error"` on all nodes at once now points at local
+ * resolution, not the directories.
+ * Incident: trustless-cello docs/planning/discussion_logs/2026-07-24_1630_post-wake-directory-dns-resolution-incident.md
+ */
+export type BootstrapFailureReason = "dns_error" | "connect_error" | "timeout" | "http_error" | "bad_response";
+export type BootstrapResult = {
+    ok: true;
+    multiaddr: string; /** How many probes it took. 1 on the happy path. */
+    attempts?: number;
+} | {
+    ok: false;
+    reason: BootstrapFailureReason;
+    detail?: string; /** How many probes were spent. */
+    attempts?: number;
+};
+/**
+ * Auto-discover the directory multiaddr via GET /bootstrap, classifying failures
+ * so callers can log a `reason` that distinguishes "this machine cannot resolve
+ * the name" from "the server is down" from "the payload is wrong".
+ */
+export interface ProbeBudget {
+    /** How many probes to spend. */
+    attempts: number;
+    /** Deadline for each probe. */
+    timeoutMs: number;
+    /** Wall-clock ceiling across all probes. */
+    totalMs: number;
+}
+/**
+ * The default: persistent. Used where nothing is waiting on the answer — the roster sweep, which
+ * runs its nodes in parallel and would rather spend 16 s than drop a healthy node.
+ */
+export declare const PERSISTENT_PROBE: ProbeBudget;
+/**
+ * FAIL-FAST, for the reconnect path — review F1, a regression the retry introduced.
+ *
+ * `createDirectoryEndpointResolver` runs on EVERY connect attempt, and the signaling stream turns
+ * over roughly every 70 seconds. Giving that path the persistent budget meant a lossy link could
+ * spend 16 s resolving before falling back to the last-known-good endpoint it already had — and
+ * `outbound-sessions` waits only 10 s for signaling before giving up, so `cello_initiate_session`
+ * would start returning `directory_signaling_timeout` where it used to get a usable endpoint in
+ * time. A resilience fix that breaks the thing it was protecting.
+ *
+ * TWO PROBES AT 2 s, AND THE ARITHMETIC IS THE POINT. The blocked resolver has TWO legs inside that
+ * one 10 s wait — the primary, and then the roster sweep, whose `Promise.all` waits for the slowest
+ * node. So the budget has to fit TWICE: 2 × 2 s × 2 legs = 8 s, with headroom. A first attempt at
+ * 4 s looked generous and was wrong for exactly this reason, and the test that now asserts it
+ * against `SIGNALING_CONNECT_WAIT_MS` is what caught it.
+ *
+ * ISN'T 2 s TOO SHORT for a link where a probe was measured at 16.2 s? Yes — and that is the honest
+ * answer rather than a problem. Inside a 10 s deadline you cannot afford a 16 s probe from either
+ * leg, so pretending to try is how the deadline gets blown and the caller gets NOTHING. Failing fast
+ * here preserves the thing that actually helps on a bad link: the last-known-good endpoint, and a
+ * background sweep on the persistent budget that keeps the roster current without anyone waiting.
+ *
+ * The retry is still the mechanism — two probes means a second, FRESH connection, which is what
+ * recovers a lost handshake. One would be the original defect.
+ */
+export declare const FAST_PROBE: ProbeBudget;
+export declare function fetchBootstrapResult(directoryUrl: string, fetchFn?: typeof fetch, nowMs?: () => number, budget?: ProbeBudget): Promise<BootstrapResult>;
+/**
+ * Auto-discover the directory multiaddr via GET /bootstrap on the directory HTTP
+ * endpoint. Returns the multiaddr (which embeds the peer ID after "/p2p/"), or null.
+ * Thin compatibility wrapper over fetchBootstrapResult (which carries the failure class).
+ */
+export declare function fetchBootstrapMultiaddr(directoryUrl: string, fetchFn?: typeof fetch): Promise<string | null>;
+/**
+ * Extract the libp2p peer ID from a multiaddr — the segment after the final
+ * "/p2p/". Returns null if absent.
+ */
+export declare function parsePeerIdFromMultiaddr(multiaddr: string): string | null;
+/** A resolved consortium directory node: its manifest identity + live dial coordinate. */
+export interface ConsortiumEndpoint {
+    /** The node's stable consortium identifier (from the manifest). */
+    nodeId: string;
+    /** The node's Ed25519 pubkey (from the manifest) — used for step-6 identity + addressing. */
+    pubkey: string;
+    /** The libp2p peer ID resolved from the node's live /bootstrap. */
+    peerId: string;
+    /** The libp2p multiaddr resolved from the node's live /bootstrap. */
+    multiaddr: string;
+}
+/**
+ * Validate + normalise a manifest node `endpoint` to the HTTP(S) base used for its
+ * `/bootstrap` probe, or return `null` if it is not a usable bootstrap base.
+ *
+ * CONTRACT: a manifest `endpoint` is the node's HTTP(S) `/bootstrap` base — production
+ * directories serve `/bootstrap` over plaintext HTTP on port 9090, directly (there is no load
+ * balancer in front of them), matching PRODUCTION_DIRECTORY_URL. 8080 on the same host speaks the
+ * libp2p WebSocket upgrade and answers plain HTTP with 400, so pointing this at 8080 resolves as
+ * zero reachable nodes from a perfectly valid manifest. The wss libp2p DIAL address is
+ * returned BY `/bootstrap`; it is NOT the endpoint. Do NOT accept (or port-guess) a
+ * `wss://host:443` value — mapping that to `http://host:443` speaks plaintext to the
+ * TLS port and silently fails. Anything
+ * that is not `http(s)://` (a bare multiaddr, a wss dial address, a typo) is a config
+ * error in officer-SIGNED data: return null so the caller logs it DISTINCTLY from a
+ * transient outage and never dials a wrong port. A single trailing slash is stripped
+ * (fetchBootstrapMultiaddr appends `/bootstrap`).
+ */
+export declare function mapEndpointToBootstrapBase(endpoint: string): string | null;
+/** Why one consortium node could not be resolved, for the operator-facing surface. */
+export interface NodeResolveFailure {
+    nodeId: string;
+    endpoint: string;
+    reason: string;
+    detail?: string;
+    /**
+     * How many probes were spent before giving up (DOD-M15-BOOTSTRAP-1).
+     *
+     * On the OPERATOR SURFACE, not only in the log, because the two shapes call for opposite
+     * responses: one probe means the node answered definitively (a 404, a bad payload) and the
+     * problem is that node's configuration; three means it never answered and the problem is the
+     * path to it.
+     */
+    attempts?: number;
+}
+export interface ManifestResolveOptions {
+    logger: Logger;
+    /**
+     * DOD-M15-BOOTSTRAP-1 (review HIGH-1) — which probe budget this sweep may spend.
+     *
+     * The first fix put `FAST_PROBE` on the resolver's PRIMARY leg and left this sweep on the
+     * persistent one. Both legs sit inside the same 10 s signaling wait, and this is the bigger:
+     * `Promise.all` waits for the slowest node, so ONE unreachable node costs the whole sweep 16 s —
+     * and the failover path pays 8 s on the primary before even starting it. The regression moved
+     * rather than went away.
+     *
+     * Defaults to persistent, which is right for startup and the background poll, where nothing is
+     * blocked. A caller that IS blocked passes `FAST_PROBE`.
+     */
+    probeBudget?: ProbeBudget;
+    /** Injectable fetch for testing. */
+    fetchFn?: typeof fetch;
+    /**
+     * Called for each node that could not be resolved.
+     *
+     * A `warn` in the log is not a surface. When this host's resolver held a cached NXDOMAIN after a
+     * wake, this fired 26 times per node while the operator was shown `counterparty_offline`, then
+     * `directory_below_threshold`, then `ceremony_exhausted` — three errors that each point somewhere
+     * other than DNS. The information existed the whole time and nothing carried it to a human.
+     */
+    onNodeUnresolved?: (failure: NodeResolveFailure) => void;
+}
+/**
+ * Resolve every consortium node in the manifest's node set to a live directory
+ * endpoint by probing each node's `/bootstrap` (in parallel, order preserved).
+ *
+ * AVAILABILITY-AWARE (the sovereign-node redundancy invariant): a node whose bootstrap is
+ * unreachable is SKIPPED with a warning — one node down must never strand the others,
+ * because a T-of-N ceremony only needs T of the N. Returns the resolved subset
+ * (possibly empty). The CALLER decides whether the resolved count meets the threshold;
+ * this function NEVER silently substitutes the single hardcoded endpoint for a missing
+ * node — that would defeat sovereignty by masking a down/forged node as healthy.
+ */
+export declare function manifestNodesToEndpoints(nodes: readonly ConsortiumNode[], opts: ManifestResolveOptions): Promise<ConsortiumEndpoint[]>;
+export interface DirectoryEndpointResolverOptions {
+    logger: Logger;
+    /** Defaults to resolveDirectoryUrl(process.env). */
+    directoryUrl?: string;
+    /** Injectable fetch for testing. */
+    fetchFn?: typeof fetch;
+    /**
+     * Whether a fresh /bootstrap failure falls back to the last known-good endpoint (default true).
+     *
+     * MUST be FALSE when this resolver is the PRIMARY probe inside createRosterAwareEndpointResolver.
+     * There, the stale-last-known-good fallback is HARMFUL — it masks a dead primary (a fresh failure
+     * returns the cached dead endpoint, so the wrapper never observes the primary as "down" and never
+     * fails over to the roster). With staleFallback:false a fresh failure returns null, and the roster
+     * becomes the real (and only) fallback. The default (true) is for unwrapped single-node callers.
+     */
+    staleFallback?: boolean;
+}
+/**
+ * Build an async `getDirectoryEndpoint` for createSignalingConnect.
+ *
+ * Re-resolves the bootstrap on EVERY call (i.e. every connect attempt) so a
+ * directory address change — failover, DNS/port change, or peer-ID rotation — is
+ * picked up on the next reconnect. The last successfully-resolved endpoint is kept
+ * only as a fallback: if a fresh fetch fails, the resolver returns the last
+ * known-good endpoint so a transient /bootstrap blip doesn't strand a working daemon.
+ */
+export declare function createDirectoryEndpointResolver(opts: DirectoryEndpointResolverOptions): () => Promise<DirectoryEndpoint | null>;
+export interface RosterAwareResolverOptions {
+    /**
+     * Resolve the PRIMARY (configured) directory endpoint — typically the result of
+     * createDirectoryEndpointResolver (probes CELLO_DIRECTORY_URL's /bootstrap).
+     */
+    primaryResolver: () => Promise<DirectoryEndpoint | null>;
+    /**
+     * Resolve the CURRENTLY-REACHABLE consortium roster. Each member returned has already
+     * had its /bootstrap probed (manifestNodesToEndpoints skips unreachable nodes), so a
+     * member's presence in the returned array IS its reachability. NULL when no consortium
+     * manifest is configured → no failover, primary-only.
+     */
+    getConsortiumRoster: () => Promise<ConsortiumEndpoint[] | null>;
+    logger: Logger;
+    /**
+     * Test seam: order the fallback candidates. Production defaults to a Fisher-Yates
+     * shuffle so clients don't stampede one node when the primary goes down (the redundancy
+     * invariant). Tests inject an identity shuffle for deterministic ordering.
+     */
+    shuffle?: <T>(items: T[]) => T[];
+    /**
+     * DECLARED consortium member peer ids, from the verified manifest. Local and free — never a
+     * network probe. Absent (or empty) disables the membership check entirely, which is the M6
+     * back-compat path where there is no manifest to be a member of.
+     */
+    getManifestPeerIds?: () => Set<string> | null;
+}
+/**
+ * Wrap a single-node primary resolver with the consortium roster so the signaling
+ * dialer (and the ceremony endpoint that shares this instance) route AROUND a down
+ * primary directory node instead of retrying the single primary URL forever — the
+ * sovereign-node REDUNDANCY invariant.
+ *
+ * Selection policy, per getDirectoryEndpoint() call:
+ *   1. Sticky-until-fail — while riding a non-primary fallback, KEEP it as long as it's
+ *      still in the reachable roster. Do NOT churn back to the primary when it recovers
+ *      (no flapping / reconnect storm). The fallback's multiaddr is refreshed from the
+ *      fresh roster match each call.
+ *   2. Primary-first — otherwise try the configured node. This is also the healthy
+ *      steady state: when the primary resolves, we return WITHOUT probing the roster
+ *      (no per-connect roster cost while everything is nominal).
+ *   3. Fallback — if the primary is down, fail over to a reachable roster member. The
+ *      order is randomized (across the members other than the dead primary) so clients
+ *      spread across the survivors. Emits directory.bootstrap.failover on a change so an
+ *      operator sees the client is now running on a non-home node.
+ *   4. Return null only when NOTHING resolves (primary down AND roster empty/absent) —
+ *      the unchanged all-nodes-down failure mode, no crash.
+ *
+ * ONE instance is shared across the daemon's signaling connect and its ceremony
+ * getDirectoryEndpoint so signaling + ceremonies stay on the SAME directory node and
+ * fail over together (a coherent per-daemon directory selection).
+ *
+ * Scope note: stickiness here is by ROSTER REACHABILITY, not by observed connect success
+ * — the resolver is not told whether a dial/auth against the returned endpoint actually
+ * succeeded. A node whose /bootstrap resolves is served by that same node, so resolvable ≈
+ * connectable in practice; only a live kill-primary failover test proves that presence
+ * resolution, relay assignment, and the FROST ceremony all work against a non-home directory.
+ */
+export declare function createRosterAwareEndpointResolver(opts: RosterAwareResolverOptions): () => Promise<DirectoryEndpoint | null>;
+//# sourceMappingURL=directory-bootstrap.d.ts.map

package/dist/directory-bootstrap.d.ts.map

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