keri-ts 0.11.0 → 2.0.0

package/esm/keri/npm/src/app/{authenticating.js → bootstrap/authenticating.js}

@@ -1,10 +1,21 @@
-import { ResourceAdmissionError } from "cesr-ts";
-import { call, resource } from "effection";
-import { closeResponseBody, fetchResponseHandle } from "./httping.js";
+import { call, scoped } from "effection";
+import { persistResolvedContact } from "../identity/organizing.js";
+import { runtimeTurn } from "../runtime/runtime-turn.js";
 import { isWellKnownOobiUrl, parseOobiUrl } from "./oobiery.js";
-import { persistResolvedContact } from "./organizing.js";
-import { resolveRuntimeServices } from "./runtime-services.js";
-import { runtimeTurn } from "./runtime-turn.js";
+/**
+ * Return true when a well-known URL has been authorized into `wkas.`.
+ *
+ * @param db Borrowed authentication records; this read acquires no runtime or I/O lifetime.
+ * @param url Exact requested OOBI/well-known URL whose durable state is inspected.
+ * @returns Whether the documented authentication/convergence predicate currently holds.
+ */
+export function hasWellKnownAuth(db, url) {
+    const cid = parseOobiUrl(url).cid;
+    if (!cid) {
+        return false;
+    }
+    return db.wkas.get(cid).some((record) => record.url === url);
+}
 /**
  * Well-known OOBI authenticator for one `Habery`.
  *
@@ -19,25 +30,29 @@ import { runtimeTurn } from "./runtime-turn.js";
  * - `wkas.` records successful `(cid, url)` authorizations
  */
 export class Authenticator {
-    constructor(hby, options = {}) {
+    /**
+     * Bind the local authentication store and its configured HTTP dependency.
+     *
+     * @param hby Borrowed local identities and accepted-state stores.
+     * @param http Borrowed HTTP implementation selected by composition.
+     */
+    constructor(hby, http) {
+        /** Borrowed local identities and durable well-known authentication records. */
         Object.defineProperty(this, "hby", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "services", {
+        /** HTTP implementation selected when this authenticator is composed. */
+        Object.defineProperty(this, "http", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        const services = options.services ?? resolveRuntimeServices({ resources: hby.db.resources });
-        if (services.resources !== hby.db.resources) {
-            throw new RangeError("Authenticator requires its Habery's resource policy");
-        }
         this.hby = hby;
-        this.services = services;
+        this.http = http;
     }
     /** Process one bounded auth step if queued well-known work exists. */
     *processOnce() {
@@ -104,32 +119,24 @@ export class Authenticator {
         }
         return null;
     }
-    /** Fetch one `mfa.` record and persist the terminal auth result. */
+    /**
+     * Fetch one `mfa.` record and persist the terminal auth result.
+     *
+     * @param url Exact pending well-known authentication URL.
+     * @param record Durable mfa record retained until response handling and cleanup establish terminal state.
+     */
     *processPendingAuth(url, record) {
-        // This endpoint uses only HTTP status, never an unbounded body collector.
-        // Logical request/handle allowance does not bound native headers or fetch buffers.
-        const admission = this.services.resources.reserve({ streams: 1, bytes: 64 * 1024 + 128 + 2 * url.length });
-        if (admission.kind === "refuse") {
-            if (admission.reason === "busy")
-                return; // Leave the existing durable pending head untouched.
-            throw new ResourceAdmissionError("Well-known HTTP request exceeds configured capacity", admission.reason);
-        }
-        // Registered before fetch: its response and late cleanup finish before this permit returns.
-        yield* resource(function* (provide) {
-            try {
-                yield* provide();
-            }
-            finally {
-                admission.reservation.release();
-            }
-        });
+        // Only HTTP status is needed; the response owner still joins body cleanup.
         const cid = record.cid
             ?? parseOobiUrl(url, record.oobialias ?? undefined).cid
             ?? null;
-        const response = yield* fetchAuthResponse(url, this.services);
+        const http = this.http;
+        const response = yield* scoped(function* () {
+            const response = yield* http.open(url);
+            return { ok: response.ok, status: response.status };
+        });
         const date = new Date().toISOString();
         const state = response.ok ? "resolved" : `http-${response.status}`;
-        yield* closeResponseBody(response);
         this.hby.db.mfa.rem(url);
         this.hby.db.rmfa.pin(url, {
             ...record,
@@ -146,9 +153,3 @@ export class Authenticator {
         }
     }
 }
-function* fetchAuthResponse(url, services) {
-    const { response } = yield* fetchResponseHandle(url, {}, {
-        services,
-    });
-    return response;
-}

package/esm/keri/npm/src/app/bootstrap/bootstrapping.js

@@ -0,0 +1,109 @@
+/** Finite introduction/authentication composition shared by environment creation and inception. */
+import { scoped, spawn } from "effection";
+import { createProtocolProcessor } from "../protocol/protocol-processing.js";
+import { runtimeTurn } from "../runtime/runtime-turn.js";
+import { Authenticator, hasWellKnownAuth } from "./authenticating.js";
+import { Oobiery, oobiTerminalState } from "./oobiery.js";
+/**
+ * Resolve this command's pending introductions and well-known authentication.
+ *
+ * The command is the sole OOBI/authentication worker owner for its borrowed Habery.
+ * Select existing oobis/coobi/moobi and woobi/mfa rows, then include children and
+ * introductions queued by processing them. Old terminal rows alone select no work.
+ * Surviving coobi/mfa/moobi rows resume through their ordinary component owners.
+ * A queued attempt takes precedence over any older terminal/authorization row.
+ * The actual table family selects its terminal evidence: a well-known URL may
+ * be an ordinary introduction, a separate authentication, or both.
+ *
+ * Like KERIpy init, compose Oobiery and Authenticator directly. Resolution means
+ * that Oobiery processed the response, not that all its protocol evidence was
+ * accepted. KEL/reply escrow processing lets evidence arriving in separate
+ * responses unlock introductions and authentication's required controller state.
+ * Escrow contents never determine bootstrap completion. Later operations must
+ * check the accepted evidence they actually require.
+ *
+ * @param hby Borrowed identities/configuration/Baser; kept open through cleanup.
+ * @param http Borrowed request implementation used by OOBIs and authentication.
+ * @param options Finite positive elapsed deadline, default 30 seconds.
+ * @returns Selected terminal success, refusal or deadline after all children/I/O join.
+ * @throws Invariant, parser, storage, transport and cleanup failures propagate unchanged.
+ */
+export function resolveBootstrap(hby, http, { timeoutMs = 30_000 } = {}) {
+    return scoped(function* bootstrapScope() {
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+            throw new RangeError("Bootstrap timeout must be finite and positive");
+        }
+        const selected = { oobis: new Set(), woobi: new Set() };
+        collectPendingUrls(hby.db, selected);
+        if (selected.oobis.size === 0 && selected.woobi.size === 0)
+            return { kind: "complete" };
+        const protocol = createProtocolProcessor(hby);
+        const oobiery = new Oobiery(hby, protocol, protocol.rvy, http, protocol.cues);
+        oobiery.registerReplyRoutes();
+        const authenticator = new Authenticator(hby, http);
+        yield* spawn(() => oobiery.oobiDo());
+        yield* spawn(() => authenticator.authDo());
+        yield* spawn(function* () {
+            while (true) {
+                protocol.processKelReplyEscrowsOnce();
+                yield* runtimeTurn();
+            }
+        });
+        const deadline = performance.now() + timeoutMs;
+        while (true) {
+            collectPendingUrls(hby.db, selected);
+            const result = inspectBootstrap(hby.db, selected);
+            if (result)
+                return result;
+            if (performance.now() >= deadline) {
+                const pending = [];
+                for (const kind of ["oobis", "woobi"]) {
+                    for (const url of selected[kind])
+                        if (!bootstrapUrlComplete(hby.db, url, kind))
+                            pending.push(url);
+                }
+                return {
+                    kind: "timeout",
+                    pending: [...new Set(pending)],
+                };
+            }
+            yield* runtimeTurn();
+        }
+    });
+}
+/** Select actual queued/in-flight records; Oobiery owns multi-OOBI child completion. */
+function collectPendingUrls(db, selected) {
+    for (const store of [db.oobis, db.coobi, db.moobi]) {
+        for (const [keys] of store.getTopItemIter())
+            if (keys[0])
+                selected.oobis.add(keys[0]);
+    }
+    for (const store of [db.woobi, db.mfa]) {
+        for (const [keys] of store.getTopItemIter())
+            if (keys[0])
+                selected.woobi.add(keys[0]);
+    }
+}
+/** Require current terminal evidence; a saved authorization cannot mask a queued retry. */
+function bootstrapUrlComplete(db, url, kind) {
+    if (oobiTerminalState(db, url, kind).status !== "resolved")
+        return false;
+    return kind === "oobis" || hasWellKnownAuth(db, url);
+}
+/** Decide only from selected URLs; absence of queue rows alone never establishes success. */
+function inspectBootstrap(db, selected) {
+    const failures = [];
+    let pending = false;
+    for (const kind of ["oobis", "woobi"]) {
+        for (const url of selected[kind]) {
+            const terminal = oobiTerminalState(db, url, kind);
+            if (terminal.status === "failed")
+                failures.push({ url, state: terminal.record?.state ?? "failed" });
+            else if (!bootstrapUrlComplete(db, url, kind))
+                pending = true;
+        }
+    }
+    if (failures.length)
+        return { kind: "failed", failures };
+    return pending ? null : { kind: "complete" };
+}

package/esm/keri/npm/src/app/bootstrap/oobi-replies.js

@@ -0,0 +1,113 @@
+/** Lazy OOBI output borrows its Hab/keeper/database; metadata capture begins only on iterator acquisition. */
+import { DatabaseOperationError } from "../../core/errors.js";
+import { genusFramed } from "../../core/genus-framing.js";
+import { Roles } from "../../core/roles.js";
+import { dgKey } from "../../db/core/keys.js";
+import { loadStoredReply } from "../delivery/stored-replies.js";
+/**
+ * Capture primitive descriptors, then emit finite messages in the established OOBI order.
+ * Selector inputs are borrowed and must stay immutable until acquisition under the caller's owner.
+ * Captured identities stop at FEL horizons; proofs/signing keys remain consumption-time state.
+ */
+export function oobiReplyMessages(hab, cid, role, eids, scheme, requireReady) {
+    return {
+        [Symbol.iterator]() {
+            const count = eids.length;
+            const selected = [];
+            for (let index = 0; index < count; index++)
+                selected.push(eids[index]);
+            // KELs, other parties' stored replies and fresh replies may legitimately differ in genus.
+            return genusFramed((function* () {
+                const parts = [], cloned = new Set();
+                const clone = (pre) => {
+                    if (!pre || cloned.has(pre))
+                        return;
+                    const kever = hab.db.getKever(pre);
+                    const delegated = kever?.delegated ?? false;
+                    if (delegated && !hab.db.aess.get(dgKey(pre, kever.lastEst.d || kever.said)))
+                        return;
+                    const captured = hab.db.replay(pre);
+                    if (!captured)
+                        return;
+                    const ranges = [
+                        ...captured.ranges.filter(([aid]) => aid !== pre),
+                        ...captured.ranges.filter(([aid]) => aid === pre),
+                    ];
+                    parts.push({ kind: "kel", pre, ranges, delegated });
+                    cloned.add(pre);
+                };
+                const locations = (eid, fresh) => {
+                    const keys = scheme ? [eid, scheme] : [eid];
+                    if (fresh) {
+                        for (const [path, loc] of hab.db.locs.getTopItemIter(keys, { topive: !scheme })) {
+                            if (!path[1] || !loc.url)
+                                continue;
+                            if (typeof loc.url !== "string")
+                                throw new DatabaseOperationError("Corrupt OOBI location URL");
+                            parts.push({ kind: "loc", eid, scheme: path[1], url: loc.url });
+                        }
+                    }
+                    else {
+                        for (const [, said] of hab.db.lans.getTopItemIter(keys, { topive: !scheme })) {
+                            parts.push({ kind: "stored", said: said.qb64 });
+                        }
+                    }
+                };
+                const target = hab.db.getKever(cid);
+                if (requireReady && target?.delegated && !hab.db.aess.get(dgKey(cid, target.lastEst.d || target.said))) {
+                    return;
+                }
+                clone(cid);
+                if (requireReady && target?.delegated && !parts.some((part) => part.kind === "kel" && part.pre === cid)) {
+                    return;
+                }
+                if (role === Roles.witness) {
+                    for (const eid of target?.wits ?? []) {
+                        if (selected.length && !selected.includes(eid))
+                            continue;
+                        clone(eid);
+                        locations(eid, eid === hab.pre);
+                        if (cid === hab.pre)
+                            parts.push({ kind: "auth", eid, role: Roles.witness });
+                    }
+                }
+                for (const [keys, end] of hab.db.ends.getTopItemIter([cid], { topive: true })) {
+                    const currentRole = keys[1], eid = keys[2];
+                    if (!currentRole || !eid || !(end.allowed || end.enabled) || (role && currentRole !== role)
+                        || (selected.length && !selected.includes(eid)))
+                        continue;
+                    clone(eid);
+                    locations(eid, false);
+                    const said = hab.db.eans.get([cid, currentRole, eid]);
+                    if (said)
+                        parts.push({ kind: "stored", said: said.qb64 });
+                }
+                // Metadata cursors have all closed before any event/body preparation or yield.
+                for (const part of parts) {
+                    if (part.kind === "kel") {
+                        let chainContent = false;
+                        for (const range of part.ranges) {
+                            if (range[0] === part.pre && part.delegated && !chainContent)
+                                break;
+                            for (const bytes of hab.db.replayRange(range)) {
+                                if (range[0] !== part.pre)
+                                    chainContent = true;
+                                yield bytes;
+                            }
+                        }
+                        if (requireReady && part.pre === cid && part.delegated && !chainContent)
+                            return;
+                    }
+                    else if (part.kind === "stored") {
+                        yield loadStoredReply(hab.db, part.said);
+                    }
+                    else {
+                        yield part.kind === "loc"
+                            ? hab.makeLocScheme(part.url, part.eid, part.scheme)
+                            : hab.makeEndRole(part.eid, part.role, true);
+                    }
+                }
+            })());
+        },
+    };
+}