keri-ts 0.11.0 → 2.0.0

package/esm/keri/npm/src/app/cli/rotate.js

@@ -1,171 +0,0 @@
-import { ValidationError } from "../../core/errors.js";
-import { createAgentRuntime, processRuntimeUntil } from "../agent-runtime.js";
-import { resolveDelegationCommunicationHab } from "../delegating.js";
-import { queryTransportSink } from "../runtime-deliveries.js";
-import { Receiptor, WitnessReceiptor } from "../witnessing.js";
-import { withExistingHab } from "./common/context.js";
-import { loadRotateFileOptions, parseDataItems, parseThresholdOption, } from "./common/parsing.js";
-import { resolveWitnessAuths } from "./common/witness-auth.js";
-/** Empty baseline used before CLI/file precedence is applied. */
-function emptyRotateOptions() {
-    return {};
-}
-/**
- * Merge CLI arguments over file-backed rotation options with KLI-compatible precedence.
- *
- * KLI quirk preserved intentionally:
- * - absent CLI `--nsith` still forces `'1'`
- * - absent CLI `--next-count` still forces `1`
- */
-function mergeWithFile(args) {
-    const options = args.file && args.file !== "" ? loadRotateFileOptions(args.file) : emptyRotateOptions();
-    if (args.isith !== undefined) {
-        options.isith = parseThresholdOption(args.isith);
-    }
-    if (args.nsith !== undefined) {
-        options.nsith = parseThresholdOption(args.nsith);
-    }
-    else {
-        options.nsith = "1";
-    }
-    if (args.nextCount !== undefined) {
-        options.ncount = Number(args.nextCount);
-    }
-    else {
-        options.ncount = 1;
-    }
-    if (args.toad !== undefined) {
-        options.toad = Number(args.toad);
-    }
-    if ((args.witnesses?.length ?? 0) > 0) {
-        options.wits = [...args.witnesses];
-    }
-    if ((args.cuts?.length ?? 0) > 0) {
-        options.witsCut = [...args.cuts];
-    }
-    if ((args.witnessAdd?.length ?? 0) > 0) {
-        options.witsAdd = [...args.witnessAdd];
-    }
-    if (args.data !== undefined) {
-        options.data = parseDataItems(args.data);
-    }
-    return options;
-}
-/** Return items present in `left` but absent from `right` while preserving order. */
-function difference(left, right) {
-    const rightSet = new Set(right);
-    return left.filter((value) => !rightSet.has(value));
-}
-/**
- * Rotate one local habitat and print the newly accepted public key state.
- *
- * Maintainer boundary:
- * - CLI concerns stop at option merge/validation and success output
- * - habitat/key-state mutation lives in `Hab.rotate(...)`
- */
-export function* rotateCommand(args) {
-    const rotateArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        alias: args.alias,
-        compat: args.compat,
-        file: args.file,
-        nextCount: args.nextCount,
-        endpoint: args.endpoint,
-        authenticate: args.authenticate,
-        code: args.code,
-        codeTime: args.codeTime,
-        proxy: args.proxy,
-        isith: args.isith,
-        nsith: args.nsith,
-        toad: args.toad,
-        witnesses: args.witnesses,
-        cuts: args.cuts,
-        witnessAdd: args.witnessAdd,
-        data: args.data,
-    };
-    if (!rotateArgs.name) {
-        throw new ValidationError("Name is required and cannot be empty");
-    }
-    if (!rotateArgs.alias) {
-        throw new ValidationError("Alias is required and cannot be empty");
-    }
-    const options = mergeWithFile(rotateArgs);
-    yield* withExistingHab(rotateArgs, rotateArgs.alias, {
-        compat: rotateArgs.compat ?? false,
-        readonly: false,
-        skipConfig: true,
-        skipSignator: true,
-    }, function* ({ hby, hab }) {
-        const kever = hab.kever;
-        if (!kever) {
-            throw new ValidationError(`Missing accepted key state for ${hab.pre}.`);
-        }
-        let cuts = [...(options.witsCut ?? [])];
-        let adds = [...(options.witsAdd ?? [])];
-        if ((options.wits?.length ?? 0) > 0) {
-            if (cuts.length > 0 || adds.length > 0) {
-                throw new ValidationError("you can only specify witnesses or cuts and add");
-            }
-            cuts = difference(kever.wits, options.wits ?? []);
-            adds = difference(options.wits ?? [], kever.wits);
-        }
-        hab.rotate({
-            isith: options.isith,
-            nsith: options.nsith,
-            ncount: options.ncount,
-            toad: options.toad,
-            cuts,
-            adds,
-            data: options.data ?? [],
-        });
-        if (hab.kever?.wits.length) {
-            const auths = resolveWitnessAuths(hab.kever.wits, rotateArgs.code ?? [], {
-                codeTime: rotateArgs.codeTime,
-                promptMissing: rotateArgs.authenticate ?? false,
-            });
-            if (rotateArgs.endpoint) {
-                const receiptor = new Receiptor(hby);
-                yield* receiptor.receipt(hab.pre, {
-                    sn: hab.kever.sn,
-                    auths,
-                });
-            }
-            else {
-                const witDoer = new WitnessReceiptor(hby);
-                yield* witDoer.submit(hab.pre, {
-                    sn: hab.kever.sn,
-                    auths,
-                });
-            }
-        }
-        let delegationPhase = null;
-        if (kever.delpre !== null && hab.kever) {
-            const communicationHab = resolveDelegationCommunicationHab(hby, rotateArgs.proxy);
-            const runtime = yield* createAgentRuntime(hby, { mode: "local" });
-            try {
-                runtime.delegating.beginLatest(hab.pre, hab.kever.sn, {
-                    communicationHab,
-                });
-                const snh = hab.kever.sn.toString(16);
-                const sink = queryTransportSink(runtime, hby, communicationHab ?? hab);
-                yield* processRuntimeUntil(runtime, () => runtime.delegating.complete(hab.pre, hab.kever.sn), { hab, sink, maxTurns: 512, pollMailbox: true });
-                delegationPhase = runtime.delegating.workflowStatus(hab.pre, snh).phase;
-            }
-            finally {
-                yield* runtime.close();
-            }
-        }
-        const state = hby.db.getState(hab.pre);
-        console.log(`Prefix  ${hab.pre}`);
-        console.log(`New Sequence No.  ${hab.kever?.sn ?? state?.s ?? ""}`);
-        for (const [idx, key] of (state?.k ?? []).entries()) {
-            console.log(`\tPublic key ${idx + 1}:  ${key}`);
-        }
-        if (delegationPhase) {
-            console.log(`Delegation status  ${delegationPhase}`);
-        }
-    });
-}

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

@@ -1,284 +0,0 @@
-import * as dntShim from "../../_dnt.shims.js";
-import { concatBytes } from "cesr-ts";
-import { ValidationError } from "../../core/errors.js";
-import { createCredential, credentialRegistryRecords, credentialRegistryStatus, credentialStreamBytes, exportCredentialStream, importCredentialStream, inceptCredentialRegistry, listCredentials, pinSchemaBytes, requireReger, revocationRecipients, revokeCredential, } from "../credential-workflows.js";
-import { withAgentRuntime, withExistingHabery } from "./common/context.js";
-/** Implement `tufa vc schema import` by pinning JSON schemas into `schema.`. */
-export function* vcSchemaImportCommand(args) {
-    const vcArgs = baseArgs(args);
-    vcArgs.schema = asStringList(args.schema);
-    yield* withVcHabery(vcArgs, function* ({ hby }) {
-        for (const path of vcArgs.schema ?? []) {
-            const schema = pinSchemaBytes(hby, dntShim.Deno.readFileSync(path));
-            console.log(JSON.stringify({ schema, path }));
-        }
-    });
-}
-/** Implement `tufa vc registry incept` for single-sig or group registries. */
-export function* vcRegistryInceptCommand(args) {
-    const vcArgs = registryArgs(args);
-    yield* withVcRuntime(vcArgs, function* ({ hby, runtime }) {
-        const hab = requireHab(hby, vcArgs.alias);
-        const result = yield* inceptCredentialRegistry(hby, runtime, hab, {
-            registryName: vcArgs.registryName,
-            noBackers: vcArgs.noBackers,
-            estOnly: vcArgs.estOnly,
-            usage: vcArgs.usage,
-        });
-        console.log(JSON.stringify(result));
-    });
-}
-/** Implement `tufa vc registry list` from local `Reger.regs` state. */
-export function* vcRegistryListCommand(args) {
-    const vcArgs = baseArgs(args);
-    yield* withVcRuntime(vcArgs, function* ({ reger }) {
-        for (const record of credentialRegistryRecords(reger)) {
-            console.log(JSON.stringify(record));
-        }
-    });
-}
-/** Implement `tufa vc registry status` from current TEL registry state. */
-export function* vcRegistryStatusCommand(args) {
-    const vcArgs = registryArgs(args, { aliasRequired: false });
-    yield* withVcRuntime(vcArgs, function* ({ runtime, reger }) {
-        console.log(JSON.stringify(credentialRegistryStatus(runtime, reger, vcArgs.registryName)));
-    });
-}
-/** Implement `tufa vc create` by constructing and issuing one registry-backed ACDC. */
-export function* vcCreateCommand(args) {
-    const vcArgs = {
-        ...baseArgs(args),
-        alias: args.alias,
-        registryName: args.registryName,
-        schema: args.schema,
-        schemaFile: args.schemaFile,
-        recipient: args.recipient,
-        data: args.data,
-        edges: args.edges,
-        rules: args.rules,
-        out: args.out,
-    };
-    requireNonEmpty(vcArgs.alias, "Alias");
-    requireNonEmpty(vcArgs.registryName, "Registry name");
-    yield* withVcRuntime(vcArgs, function* ({ hby, runtime, reger }) {
-        const schema = vcArgs.schemaFile ? pinSchemaBytes(hby, dntShim.Deno.readFileSync(vcArgs.schemaFile)) : vcArgs.schema;
-        requireNonEmpty(schema, "Schema");
-        const recipient = vcArgs.recipient ? resolveAid(hby, vcArgs.recipient) : undefined;
-        const result = yield* createCredential(hby, runtime, reger, {
-            registryName: vcArgs.registryName,
-            schema: schema,
-            recipient,
-            data: parseSubjectDataArg(vcArgs.data) ?? {},
-            edges: parseJsonSectionArg(vcArgs.edges, "edges"),
-            rules: parseJsonSectionArg(vcArgs.rules, "rules"),
-        });
-        if (vcArgs.out) {
-            writeBytes(credentialStreamBytes(hby, reger, result.creder, result.recipient), vcArgs.out);
-        }
-        console.log(JSON.stringify(result.output));
-    });
-}
-/** Implement `tufa vc list` over verifier-backed wallet indexes. */
-export function* vcListCommand(args) {
-    const vcArgs = {
-        ...baseArgs(args),
-        alias: args.alias,
-        aid: args.aid,
-        schema: args.schema,
-        issued: args.issued,
-    };
-    yield* withVcRuntime(vcArgs, function* ({ hby, runtime, reger }) {
-        const aid = vcArgs.aid ?? (vcArgs.alias ? requireHab(hby, vcArgs.alias).pre : undefined);
-        for (const item of listCredentials(runtime, reger, { issued: vcArgs.issued ?? false, aid, schema: vcArgs.schema })) {
-            console.log(JSON.stringify(item));
-        }
-    });
-}
-/** Implement `tufa vc export` as a KERIpy-compatible credential support stream. */
-export function* vcExportCommand(args) {
-    const vcArgs = {
-        ...baseArgs(args),
-        said: args.said,
-        recipient: args.recipient,
-        out: args.out,
-    };
-    requireNonEmpty(vcArgs.said, "Credential SAID");
-    yield* withVcRuntime(vcArgs, function* ({ hby, reger }) {
-        const recipient = vcArgs.recipient ? resolveAid(hby, vcArgs.recipient) : undefined;
-        const result = exportCredentialStream(hby, reger, vcArgs.said, recipient);
-        writeBytes(result.bytes, vcArgs.out);
-    });
-}
-/** Implement `tufa vc import` by ingesting one CESR credential stream. */
-export function* vcImportCommand(args) {
-    const vcArgs = {
-        ...baseArgs(args),
-        inPath: args.inPath,
-    };
-    yield* withVcRuntime(vcArgs, function* ({ runtime, reger }) {
-        console.log(JSON.stringify(yield* importCredentialStream(runtime, reger, readBytes(vcArgs.inPath))));
-    });
-}
-/** Implement `tufa vc revoke`, including optional revocation delivery/export. */
-export function* vcRevokeCommand(args) {
-    const vcArgs = {
-        ...baseArgs(args),
-        alias: args.alias,
-        registryName: args.registryName,
-        said: args.said,
-        recipient: args.recipient,
-        out: args.out,
-        send: asStringList(args.send),
-        delivery: args.delivery,
-    };
-    requireNonEmpty(vcArgs.registryName, "Registry name");
-    requireNonEmpty(vcArgs.said, "Credential SAID");
-    yield* withVcRuntime(vcArgs, function* ({ hby, runtime, reger }) {
-        const [creder] = reger.cloneCred(vcArgs.said);
-        if ((vcArgs.send?.length ?? 0) > 0 && !vcArgs.alias) {
-            throw new ValidationError("Alias is required when sending revocation events.");
-        }
-        const sendRecipients = revocationRecipients(creder, vcArgs.send ?? [], !!vcArgs.alias);
-        const senderHab = sendRecipients.length > 0 ? requireHab(hby, vcArgs.alias) : undefined;
-        const result = yield* revokeCredential(hby, runtime, reger, {
-            registryName: vcArgs.registryName,
-            credentialSaid: vcArgs.said,
-            sendRecipients,
-            senderHab,
-            delivery: vcArgs.delivery,
-        });
-        if (vcArgs.out) {
-            const recipient = vcArgs.recipient ? resolveAid(hby, vcArgs.recipient) : result.creder.issuee ?? "";
-            writeBytes(credentialStreamBytes(hby, reger, result.creder, recipient), vcArgs.out);
-        }
-        console.log(JSON.stringify({
-            said: result.said,
-            tel: result.tel,
-            status: result.status,
-            deliveries: result.deliveries,
-            queued: result.queued,
-        }));
-    });
-}
-function baseArgs(args) {
-    return {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        compat: args.compat,
-    };
-}
-function registryArgs(args, { aliasRequired = true } = {}) {
-    const parsed = {
-        ...baseArgs(args),
-        alias: args.alias,
-        registryName: args.registryName,
-        noBackers: args.noBackers,
-        estOnly: args.estOnly,
-        usage: args.usage,
-    };
-    if (aliasRequired) {
-        requireNonEmpty(parsed.alias, "Alias");
-    }
-    requireNonEmpty(parsed.registryName, "Registry name");
-    return parsed;
-}
-function* withVcHabery(args, use) {
-    requireNonEmpty(args.name, "Name");
-    return yield* withExistingHabery(args, vcOpenOptions(args), use);
-}
-function* withVcRuntime(args, use) {
-    requireNonEmpty(args.name, "Name");
-    return yield* withAgentRuntime(args, vcOpenOptions(args), function* ({ hby, runtime }) {
-        const reger = requireReger(runtime);
-        return yield* use({ hby, runtime, reger });
-    });
-}
-function vcOpenOptions(args) {
-    return {
-        compat: args.compat ?? false,
-        skipConfig: true,
-    };
-}
-function requireHab(hby, alias) {
-    requireNonEmpty(alias, "Alias");
-    const hab = hby.habByName(alias);
-    if (!hab?.pre) {
-        throw new ValidationError(`No local AID found for alias ${alias}.`);
-    }
-    return hab;
-}
-function resolveAid(hby, value) {
-    const local = hby.habByName(value);
-    if (local?.pre) {
-        return local.pre;
-    }
-    return value;
-}
-function parseJsonArg(value) {
-    if (!value) {
-        return undefined;
-    }
-    const text = value.startsWith("@") ? dntShim.Deno.readTextFileSync(value.slice(1)) : value;
-    return JSON.parse(text);
-}
-function parseSubjectDataArg(value) {
-    const parsed = parseJsonArg(value);
-    if (parsed === undefined) {
-        return undefined;
-    }
-    if (isRecord(parsed) || typeof parsed === "string") {
-        return parsed;
-    }
-    throw new ValidationError("data must be a JSON object or string.");
-}
-function parseJsonSectionArg(value, label) {
-    const parsed = parseJsonArg(value);
-    if (parsed === undefined) {
-        return undefined;
-    }
-    if (isRecord(parsed)) {
-        return parsed;
-    }
-    if (Array.isArray(parsed) && parsed.every(isRecord)) {
-        return parsed;
-    }
-    throw new ValidationError(`${label} must be a JSON object or array of objects.`);
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readBytes(path) {
-    if (path) {
-        return dntShim.Deno.readFileSync(path);
-    }
-    const chunks = [];
-    const buffer = new Uint8Array(64 * 1024);
-    while (true) {
-        const read = dntShim.Deno.stdin.readSync(buffer);
-        if (read === null) {
-            break;
-        }
-        chunks.push(buffer.slice(0, read));
-    }
-    return chunks.length === 0 ? new Uint8Array() : concatBytes(...chunks);
-}
-function writeBytes(bytes, path) {
-    if (path) {
-        dntShim.Deno.writeFileSync(path, bytes);
-        return;
-    }
-    dntShim.Deno.stdout.writeSync(bytes);
-}
-function asStringList(value) {
-    if (Array.isArray(value)) {
-        return value.filter((entry) => typeof entry === "string");
-    }
-    return typeof value === "string" ? [value] : [];
-}
-function requireNonEmpty(value, label) {
-    if (!value) {
-        throw new ValidationError(`${label} is required and cannot be empty.`);
-    }
-}

package/esm/keri/npm/src/app/cli/verifier.js

@@ -1,96 +0,0 @@
-import * as dntShim from "../../_dnt.shims.js";
-import { action } from "effection";
-import { ValidationError } from "../../core/errors.js";
-import { Reger } from "../../db/reger.js";
-import { createVerifierCueBaser } from "../../db/verifier-cueing.js";
-import { validatorsFromVerifierConfig, VerifierAgent } from "../verifier-agent.js";
-import { withAgentRuntime } from "./common/context.js";
-export function* verifierRunCommand(args) {
-    const runArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        compat: args.compat,
-        hook: args.hook,
-        config: args.config,
-        once: args.once,
-        intervalMs: numberArg(args.intervalMs, 1000),
-        timeoutMs: numberArg(args.timeoutMs, undefined),
-    };
-    requireNonEmpty(runArgs.name, "Name");
-    requireNonEmpty(runArgs.hook, "Webhook URL");
-    const hook = runArgs.hook;
-    yield* withAgentRuntime(runArgs, {
-        compat: runArgs.compat ?? false,
-        skipConfig: true,
-    }, function* ({ hby, runtime }) {
-        const reger = requireReger(runtime);
-        const cdb = yield* createVerifierCueBaser({
-            name: hby.name,
-            base: hby.base,
-            temp: hby.temp,
-            headDirPath: hby.headDirPath,
-            compat: hby.compat,
-        });
-        try {
-            const config = runArgs.config ? JSON.parse(dntShim.Deno.readTextFileSync(runArgs.config)) : {};
-            const agent = new VerifierAgent({
-                hby,
-                reger,
-                cdb,
-                reactor: runtime.reactor,
-                cues: runtime.cues,
-                services: runtime.services,
-                hook,
-                timeoutMs: runArgs.timeoutMs,
-                validators: validatorsFromVerifierConfig(config),
-                requireKnownSchemas: isRecord(config) && config.requireKnownSchemas === true,
-            });
-            if (runArgs.once ?? false) {
-                const result = yield* agent.processOnce();
-                console.log(JSON.stringify({ result, counts: cdb.getCounts() }));
-                return;
-            }
-            while (true) {
-                const result = yield* agent.processOnce();
-                console.log(JSON.stringify({ result, counts: cdb.getCounts() }));
-                yield* sleep(runArgs.intervalMs ?? 1000);
-            }
-        }
-        finally {
-            yield* cdb.close();
-        }
-    });
-}
-function requireReger(runtime) {
-    const reger = runtime.vdr.reger;
-    if (!(reger instanceof Reger)) {
-        throw new ValidationError("VDR runtime did not open Reger.");
-    }
-    return reger;
-}
-function* sleep(ms) {
-    yield* action((resolve) => {
-        const timeoutId = setTimeout(() => resolve(undefined), ms);
-        return () => clearTimeout(timeoutId);
-    });
-}
-function numberArg(value, fallback) {
-    if (value === undefined || value === null || value === "") {
-        return fallback;
-    }
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed < 0) {
-        throw new ValidationError(`Invalid numeric argument ${String(value)}.`);
-    }
-    return parsed;
-}
-function requireNonEmpty(value, label) {
-    if (!value) {
-        throw new ValidationError(`${label} is required and cannot be empty.`);
-    }
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}