keri-ts 2.0.1 → 2.2.0

package/esm/keri/npm/src/cli/credentials/vc.js

@@ -1,15 +1,15 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { concatBytes } from "cesr-ts";
-import { call, spawn } from "effection";
 import { importCredentialStream } from "../../app/credentials/credential-importing.js";
 import { deliverCredentialRevocation, revocationRecipients, revokeCredential, } from "../../app/credentials/credential-revoking.js";
 import { createCredential, credentialRegistryRecords, credentialRegistryStatus, credentialStreamBytes, exportCredentialStream, inceptCredentialRegistry, listCredentials, pinSchemaBytes, } from "../../app/credentials/credential-workflows.js";
+import { waitForIssuedCredential, waitForTelEvent } from "../../app/credentials/tel-completion.js";
 import { isLocalGroupHab, localGroupMember } from "../../app/multisig/group-members.js";
-import { runAgentRuntime } from "../../app/runtime/agent-runtime.js";
+import { proposeCredentialIssue, proposeCredentialRegistry, proposeCredentialRevocation, } from "../../app/multisig/proposing.js";
 import { ValidationError } from "../../core/errors.js";
 import { withAgentRuntime, withExistingHabery } from "../common/context.js";
 import { parseBooleanOption, parseNumberOption, parseStringListOption, parseStringOption } from "../common/parsing.js";
-import { waitForIssuedCredential, waitForTelPublication } from "../common/tel-completion.js";
+import { withRuntimeWorkers } from "../common/runtime-workers.js";
 /** Implement `tufa vc schema import` by pinning JSON schemas into `schema.`. */
 export function* vcSchemaImportCommand(args) {
     const vcArgs = {
@@ -35,29 +35,22 @@ export function* vcRegistryInceptCommand(args) {
         const hab = requireHab(hby, vcArgs.alias);
         const group = isLocalGroupHab(hby, hab);
         const signer = group ? localGroupMember(hby, hab.pre) : hab;
-        const result = yield* call(function* () {
-            const postman = runtime.postman;
-            const worker = yield* spawn(() => runAgentRuntime(runtime, { hab: signer, pollMailbox: group }));
-            try {
-                const deadline = Date.now() + timeout * 1000;
-                const created = yield* inceptCredentialRegistry(rgy, runtime.reactor, postman, hab, {
-                    registryName: vcArgs.registryName,
-                    estOnly: vcArgs.estOnly,
-                    usage: vcArgs.usage,
-                });
-                created.publicationComplete = yield* waitForTelPublication(rgy.publication, created.registry, 0, deadline);
-                if (created.group) {
-                    created.group.accepted = rgy.reger.tels.getOn(created.registry, 0)?.qb64 === created.registry;
-                    if (created.group.accepted)
-                        created.group.status = "accept";
-                }
-                return created;
-            }
-            finally {
-                yield* worker.halt();
+        return yield* withRuntimeWorkers(runtime, { hab: signer, pollMailbox: group }, function* () {
+            const deadline = Date.now() + timeout * 1000;
+            const options = { registryName: vcArgs.registryName, estOnly: vcArgs.estOnly, usage: vcArgs.usage };
+            const created = group
+                ? yield* proposeCredentialRegistry(proposeDeps(rgy, runtime), hab, options, GROUP_INPUTS)
+                : yield* inceptCredentialRegistry(rgy, runtime.reactor, runtime.postman, hab, options);
+            const waited = yield* waitForTelEvent(rgy, created.registry, 0, { deadline });
+            created.publicationComplete = waited.outcome === "settled";
+            // Report the accepted state the wait ended with; sending the proposal is not acceptance.
+            if (created.group) {
+                created.group.accepted = rgy.reger.tels.getOn(created.registry, 0)?.qb64 === created.registry;
+                if (created.group.accepted)
+                    created.group.status = "accept";
             }
+            return created;
         });
-        return result;
     });
 }
 /** Implement `tufa vc registry list` from local `Reger.regs` state. */
@@ -112,34 +105,23 @@ export function* vcCreateCommand(args) {
             throw new ValidationError("Selected alias does not control this registry.");
         const group = isLocalGroupHab(hby, issuer);
         const signer = group ? localGroupMember(hby, issuer.pre) : issuer;
-        const result = yield* call(function* () {
-            const postman = runtime.postman;
-            const worker = yield* spawn(() => runAgentRuntime(runtime, { hab: signer, pollMailbox: group }));
-            try {
-                const deadline = Date.now() + timeout * 1000;
-                const created = yield* createCredential(rgy, runtime.reactor, postman, {
-                    registryName: vcArgs.registryName,
-                    schema: schema,
-                    recipient,
-                    data,
-                    edges,
-                    rules,
-                });
-                yield* waitForIssuedCredential(rgy.publication, created.creder.said, deadline);
-                const saved = rgy.reger.saved.get(created.creder.said) !== null;
-                created.publicationComplete = rgy.publication.complete(created.creder.said);
-                if (saved)
-                    created.status = "accept";
-                if (created.group) {
-                    created.group.saved = saved;
-                    if (rgy.reger.tels.getOn(created.creder.said, 0)?.qb64 === created.tel)
-                        created.group.telStatus = "accept";
-                }
-                return created;
-            }
-            finally {
-                yield* worker.halt();
+        const result = yield* withRuntimeWorkers(runtime, { hab: signer, pollMailbox: group }, function* () {
+            const deadline = Date.now() + timeout * 1000;
+            const options = { registryName: vcArgs.registryName, schema: schema, recipient, data, edges, rules };
+            const created = group
+                ? yield* proposeCredentialIssue(proposeDeps(rgy, runtime), options, GROUP_INPUTS)
+                : yield* createCredential(rgy, runtime.reactor, runtime.postman, options);
+            yield* waitForIssuedCredential(rgy, created.creder.said, { deadline });
+            const saved = rgy.reger.saved.get(created.creder.said) !== null;
+            created.publicationComplete = rgy.publication.complete(created.creder.said);
+            if (saved)
+                created.status = "accept";
+            if (created.group) {
+                created.group.saved = saved;
+                if (rgy.reger.tels.getOn(created.creder.said, 0)?.qb64 === created.tel)
+                    created.group.telStatus = "accept";
             }
+            return created;
         });
         if (vcArgs.out) {
             writeBytes(credentialStreamBytes(hby, reger, result.creder, result.recipient), vcArgs.out);
@@ -235,28 +217,22 @@ export function* vcRevokeCommand(args) {
         }
         const group = isLocalGroupHab(hby, registry.hab);
         const signer = group ? localGroupMember(hby, registry.hab.pre) : registry.hab;
-        const result = yield* call(function* () {
-            const postman = runtime.postman;
-            const worker = yield* spawn(() => runAgentRuntime(runtime, { hab: signer, pollMailbox: group }));
-            try {
-                const deadline = Date.now() + timeout * 1000;
-                const revoked = yield* revokeCredential(rgy, runtime.reactor, postman, {
-                    registryName: vcArgs.registryName,
-                    credentialSaid: vcArgs.said,
-                });
-                revoked.publicationComplete = yield* waitForTelPublication(rgy.publication, revoked.said, 1, deadline);
-                revoked.accepted = reger.tels.getOn(revoked.said, 1)?.qb64 === revoked.tel;
-                if (revoked.accepted)
-                    revoked.status = "accept";
-                const recipients = revocationRecipients(revoked.creder, vcArgs.send ?? [], !!vcArgs.alias);
-                if (recipients.length > 0) {
-                    revoked.deliveries = yield* deliverCredentialRevocation(rgy, postman, revoked.said, recipients);
-                }
-                return revoked;
-            }
-            finally {
-                yield* worker.halt();
+        const result = yield* withRuntimeWorkers(runtime, { hab: signer, pollMailbox: group }, function* () {
+            const deadline = Date.now() + timeout * 1000;
+            const options = { registryName: vcArgs.registryName, credentialSaid: vcArgs.said };
+            const revoked = group
+                ? yield* proposeCredentialRevocation(proposeDeps(rgy, runtime), options, GROUP_INPUTS)
+                : yield* revokeCredential(rgy, runtime.reactor, runtime.postman, options);
+            const waited = yield* waitForTelEvent(rgy, revoked.said, 1, { deadline });
+            revoked.publicationComplete = waited.outcome === "settled";
+            revoked.accepted = reger.tels.getOn(revoked.said, 1)?.qb64 === revoked.tel;
+            if (revoked.accepted)
+                revoked.status = "accept";
+            const recipients = revocationRecipients(revoked.creder, vcArgs.send ?? [], !!vcArgs.alias);
+            if (recipients.length > 0) {
+                revoked.deliveries = yield* deliverCredentialRevocation(rgy, runtime.postman, revoked.said, recipients);
             }
+            return revoked;
         });
         if (vcArgs.out && result.accepted && result.publicationComplete) {
             const recipient = vcArgs.recipient ? resolveAid(hby, vcArgs.recipient) : result.creder.issuee ?? "";
@@ -265,6 +241,11 @@ export function* vcRevokeCommand(args) {
         return result;
     });
 }
+/** Every group member submits receipts for the anchors it proposes, as this command always has. */
+const GROUP_INPUTS = { fallbackAfterMs: 0 };
+function proposeDeps(rgy, runtime) {
+    return { rgy, input: runtime.reactor, postman: runtime.postman, counselor: runtime.counselor };
+}
 function baseArgs(args) {
     return {
         name: parseStringOption(args.name, "name"),

package/esm/keri/npm/src/cli/endpoints/did.js

@@ -2,13 +2,14 @@
  * DID-related CLI operations shared by the Tufa command dispatcher.
  */
 import * as dntShim from "../../_dnt.shims.js";
+import { beginOobi, waitForOobi } from "../../app/bootstrap/oobi-resolving.js";
 import { isLocalGroupHab } from "../../app/multisig/group-members.js";
-import { runAgentRuntimeUntil, runtimeOobiConverged } from "../../app/runtime/agent-runtime.js";
 import { WitnessReceiptor } from "../../app/witness/receipting.js";
 import { ValidationError } from "../../core/errors.js";
 import { bindDesignatedAliases, DEFAULT_DESIGNATED_ALIASES_REGISTRY_NAME, generateDidWebsArtifacts, parseDidKeriIdentifier, parseDidWebs, resolveDidKeri, resolveDidWebs, } from "../../did/index.js";
 import { withAgentRuntime } from "../common/context.js";
 import { parseBooleanOption, parseStringListOption, parseStringOption, requireNonEmpty } from "../common/parsing.js";
+import { withRuntimeWorkers } from "../common/runtime-workers.js";
 /** Implement `tufa dws bind`. */
 export function* dwsBindCommand(args) {
     const commandArgs = {
@@ -125,9 +126,17 @@ export function* dkrResolveCommand(args) {
         if (!rgy)
             throw new ValidationError("Legacy credential registry is unavailable in this runtime.");
         for (const oobi of commandArgs.oobis)
-            runtime.oobiery.resolve(oobi);
+            beginOobi({ oobiery: runtime.oobiery }, oobi);
         if (commandArgs.oobis.length > 0) {
-            yield* runAgentRuntimeUntil(runtime, () => commandArgs.oobis.every((url) => runtimeOobiConverged(runtime, url)), { timeoutMs: 30_000, pollMailbox: false });
+            // Each wait observes its own URL's record; the jobs progress together under one set of workers.
+            yield* withRuntimeWorkers(runtime, { pollMailbox: false }, function* () {
+                for (const url of commandArgs.oobis) {
+                    const result = yield* waitForOobi({ db: hby.db }, url, { timeoutMs: 30_000 });
+                    if (result.outcome === "timed-out") {
+                        throw new Error(`OOBI ${url} did not resolve within ${result.timeoutMs}ms.`);
+                    }
+                }
+            });
         }
         const result = resolveDidKeri(hby, rgy, did);
         console.log(JSON.stringify(commandArgs.meta ? result.resolution : result.document, null, 2));

package/esm/keri/npm/src/cli/endpoints/oobi-clean.js

@@ -2,9 +2,10 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { call } from "effection";
 import { DatabaseOperationError, ValidationError } from "../../core/errors.js";
-import { baserDefaults } from "../../db/baser-defaults.js";
-import { createBaser } from "../../db/basing.js";
+import { Baser } from "../../db/basing.js";
+import { lmdbDefaultsFor } from "../../db/core/lmdb-opener.js";
 import { PathManager } from "../../db/core/path-manager.js";
+import { createBaser } from "../../db/lmdb-stores.js";
 import { parseBooleanOption, parseStringOption } from "../common/parsing.js";
 import { writeJsonLine } from "../common/rendering.js";
 /** Read a nonempty JSON list, preserving exact keys and first-seen order. */
@@ -56,7 +57,7 @@ export function* oobiCleanCommand(args) {
     const keys = yield* loadKeys(args.keyFile);
     // Resolve through ordinary path preparation before Baser can create data.mdb.
     // Empty directories are ordinary startup effects; missing databases still fail.
-    const paths = new PathManager(options, baserDefaults(options.compat));
+    const paths = new PathManager(options, lmdbDefaultsFor(Baser.Family, options.compat));
     paths.name = name;
     yield* paths.reopen();
     const path = paths.path;

package/esm/keri/npm/src/cli/endpoints/oobi.js

@@ -1,13 +1,13 @@
-import { oobiTerminalState } from "../../app/bootstrap/oobiery.js";
+import { resolveOobi } from "../../app/bootstrap/oobi-resolving.js";
 import { OOBI_MAILBOX_TOPIC, OOBI_REQUEST_ROUTE, oobiRequestExn } from "../../app/bootstrap/oobiery.js";
 import { sendExchangeMessage } from "../../app/exchanges/exchange-messaging.js";
-import { enqueueOobi, runAgentRuntimeUntil, runtimeOobiConverged } from "../../app/runtime/agent-runtime.js";
 import { systemClock } from "../../app/runtime/runtime-clock.js";
-import { FetchHttpClient } from "../../app/transport/http-client.js";
+import { NodeHttpClient } from "../../app/transport/node-http-client.js";
 import { ValidationError } from "../../core/errors.js";
 import { EndpointRoles, isEndpointRole } from "../../core/roles.js";
 import { parseBooleanOption, parseStringOption } from "../common/parsing.js";
 import { withAgentRuntime, withExistingHab } from "../common/context.js";
+import { withRuntimeWorkers } from "../common/runtime-workers.js";
 /**
  * Choose one preferred URL from a scheme-keyed location map.
  *
@@ -107,7 +107,9 @@ export function* oobiGenerateCommand(args) {
  *
  * The command queues one OOBI job, runs the shared workers, and succeeds only if
  * the URL lands in `roobi.`. Any reply/event material fetched from the OOBI is
- * forced through the same parser/routing path used by the long-lived host.
+ * forced through the same parser/routing path used by the long-lived host. It
+ * waits on that URL's own record, never on unrelated pending runtime work such
+ * as group proposals or delegation escrows.
  */
 export function* oobiResolveCommand(args) {
     const commandArgs = {
@@ -132,17 +134,12 @@ export function* oobiResolveCommand(args) {
         skipConfig: false,
         skipSignator: false,
     }, function* ({ runtime }) {
-        enqueueOobi(runtime, {
-            url,
-            alias: commandArgs.oobiAlias,
-        });
-        yield* runAgentRuntimeUntil(runtime, () => runtimeOobiConverged(runtime, url), { timeoutMs: 30_000, pollMailbox: false });
-        const terminal = oobiTerminalState(runtime.hby.db, url);
-        if (terminal.status === "failed") {
-            throw new ValidationError(`OOBI ${url} failed: ${terminal.record?.state ?? "failed"}`);
+        const result = yield* withRuntimeWorkers(runtime, { pollMailbox: false }, () => resolveOobi({ oobiery: runtime.oobiery, db: runtime.hby.db }, url, { alias: commandArgs.oobiAlias, timeoutMs: 30_000 }));
+        if (result.outcome === "timed-out") {
+            throw new Error(`OOBI ${url} did not resolve within ${result.timeoutMs}ms.`);
         }
-        if (terminal.status !== "resolved") {
-            throw new ValidationError(`OOBI ${url} did not resolve.`);
+        if (result.status.state === "failed") {
+            throw new ValidationError(`OOBI ${url} failed: ${result.status.reason}`);
         }
         console.log(url);
     });
@@ -191,7 +188,7 @@ export function* oobiRequestCommand(args) {
         skipSignator: false,
     }, function* ({ hby, hab }) {
         const exn = oobiRequestExn(hab, recipient, url);
-        const { serder } = yield* sendExchangeMessage(hby, hab, new FetchHttpClient(), systemClock, {
+        const { serder } = yield* sendExchangeMessage(hby, hab, new NodeHttpClient(), systemClock, {
             dest: recipient,
             route: OOBI_REQUEST_ROUTE,
             topic: OOBI_MAILBOX_TOPIC,

package/esm/keri/npm/src/cli/identity/challenge.js

@@ -1,14 +1,11 @@
-import { action, spawn } from "effection";
-import { sendExchangeMessage } from "../../app/exchanges/exchange-messaging.js";
-import { CHALLENGE_RESPONSE_ROUTE, findVerifiedChallengeResponse, formatChallengeWords, generateChallengeWords, markChallengeVerified, parseChallengeWords, } from "../../app/identity/challenging.js";
+import { challengeStatus, formatChallengeWords, generateChallengeWords, markChallengeVerified, parseChallengeWords, respondToChallenge, waitForChallengeResponse, } from "../../app/identity/challenging.js";
 import { Organizer } from "../../app/identity/organizing.js";
-import { isLocalGroupHab } from "../../app/multisig/group-members.js";
-import { runAgentRuntime } from "../../app/runtime/agent-runtime.js";
 import { systemClock } from "../../app/runtime/runtime-clock.js";
-import { FetchHttpClient } from "../../app/transport/http-client.js";
+import { NodeHttpClient } from "../../app/transport/node-http-client.js";
 import { ValidationError } from "../../core/errors.js";
 import { parseBooleanOption, parseIntegerOption, parseNumberOption, parseStringOption } from "../common/parsing.js";
 import { withAgentRuntime, withExistingHab } from "../common/context.js";
+import { withRuntimeWorkers } from "../common/runtime-workers.js";
 /** Implement `tufa challenge generate`. */
 export function* challengeGenerateCommand(args) {
     const commandArgs = {
@@ -58,16 +55,7 @@ export function* challengeRespondCommand(args) {
         skipConfig: false,
         skipSignator: false,
     }, function* ({ hby, hab }) {
-        if (isLocalGroupHab(hby, hab)) {
-            throw new ValidationError("Challenge respond does not coordinate group approval. Select the responding member alias.");
-        }
-        const payload = { words };
-        const { serder } = yield* sendExchangeMessage(hby, hab, new FetchHttpClient(), systemClock, {
-            dest: recipient,
-            route: CHALLENGE_RESPONSE_ROUTE,
-            topic: "challenge",
-            payload: { i: hab.pre, ...payload },
-        });
+        const serder = yield* respondToChallenge({ hby, http: new NodeHttpClient(), clock: systemClock }, hab, recipient, words);
         console.log("Sent EXN message");
         console.log(serder.pretty());
     });
@@ -125,20 +113,12 @@ export function* challengeVerifyCommand(args) {
         runtime.mailboxDirector.registerTopic("/challenge");
         const timeoutMs = commandArgs.timeout * 1000;
         const pollDelayMs = commandArgs.pollDelayMs;
-        const deadline = Date.now() + timeoutMs;
-        let match = findVerifiedChallengeResponse(hby.db, signer, words);
-        if (!match && timeoutMs > 0) {
-            const worker = yield* spawn(() => runAgentRuntime(runtime));
-            try {
-                while (!match && Date.now() < deadline) {
-                    yield* sleep(Math.min(pollDelayMs, Math.max(0, deadline - Date.now())));
-                    match = findVerifiedChallengeResponse(hby.db, signer, words);
-                }
-            }
-            finally {
-                yield* worker.halt();
-            }
+        let status = challengeStatus(hby, signer, words);
+        if (status.state === "waiting" && timeoutMs > 0) {
+            const waited = yield* withRuntimeWorkers(runtime, {}, () => waitForChallengeResponse(hby, signer, words, { timeoutMs, pollMs: pollDelayMs }));
+            status = waited.status;
         }
+        const match = status.state === "waiting" ? null : status.response;
         if (!match) {
             throw new ValidationError(`No challenge response from ${signerInput} matched the provided words.`);
         }
@@ -166,12 +146,6 @@ function normalizeOutput(input) {
     }
     throw new ValidationError(`Unsupported challenge output ${String(input)}.`);
 }
-function* sleep(ms) {
-    yield* action((resolve) => {
-        const timeoutId = setTimeout(() => resolve(undefined), ms);
-        return () => clearTimeout(timeoutId);
-    });
-}
 /** Challenge entropy is a positive whole bit count; omission selects the command default. */
 function parseStrength(value) {
     const strength = parseIntegerOption(value, "strength") ?? 128;