keri-ts 0.10.1 → 0.10.2

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

@@ -1,284 +0,0 @@
-import * as dntShim from "../../../../_dnt.shims.js";
-import { concatBytes } from "../../../../cesr/mod.js";
-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(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/keri/src/app/cli/verifier.js

@@ -1,102 +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* processAgentOnce(agent);
-                console.log(JSON.stringify({ result, counts: cdb.getCounts() }));
-                return;
-            }
-            while (true) {
-                const result = yield* processAgentOnce(agent);
-                console.log(JSON.stringify({ result, counts: cdb.getCounts() }));
-                yield* sleep(runArgs.intervalMs ?? 1000);
-            }
-        }
-        finally {
-            yield* cdb.close();
-        }
-    });
-}
-function* processAgentOnce(agent) {
-    return yield* action((resolve, reject) => {
-        agent.processOnce().then(resolve, reject);
-        return () => { };
-    });
-}
-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);
-}

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

@@ -1,65 +0,0 @@
-import { Siger } from "../../../../cesr/mod.js";
-import { ValidationError } from "../../core/errors.js";
-import { withExistingHabery } from "./common/context.js";
-import { loadTextArgument } from "./common/parsing.js";
-/**
- * Verify one or more indexed signatures against locally accepted key state.
- *
- * KLI/KERIpy compatibility:
- * - `--signature` values are raw qb64 signatures, not the numbered lines from
- *   `tufa sign`
- * - each `Siger` is rebound to `kever.verfers[index]` before verification
- */
-export function* verifyCommand(args) {
-    const verifyArgs = {
-        name: args.name,
-        base: args.base,
-        headDirPath: args.headDirPath,
-        passcode: args.passcode,
-        prefix: args.prefix,
-        compat: args.compat,
-        text: args.text,
-        signature: args.signature,
-    };
-    if (!verifyArgs.name) {
-        throw new ValidationError("Name is required and cannot be empty");
-    }
-    if (!verifyArgs.prefix) {
-        throw new ValidationError("Prefix is required and cannot be empty");
-    }
-    if (!verifyArgs.text) {
-        throw new ValidationError("Text is required and cannot be empty");
-    }
-    if (!verifyArgs.signature || verifyArgs.signature.length === 0) {
-        throw new ValidationError("At least one signature is required");
-    }
-    const prefix = verifyArgs.prefix;
-    const text = verifyArgs.text;
-    const signatures = verifyArgs.signature;
-    yield* withExistingHabery(verifyArgs, {
-        compat: verifyArgs.compat ?? false,
-        readonly: false,
-        skipConfig: true,
-        skipSignator: true,
-    }, function* ({ hby }) {
-        const kever = hby.db.getKever(prefix);
-        if (!kever) {
-            throw new ValidationError(`No known key state for prefix ${prefix}.`);
-        }
-        const ser = loadTextArgument(text);
-        for (const rawSignature of signatures) {
-            const siger = new Siger({ qb64: rawSignature });
-            if (siger.index >= kever.verfers.length) {
-                throw new ValidationError(`Index = ${siger.index} to large for keys.`);
-            }
-            const verfer = kever.verfers[siger.index];
-            if (!verfer) {
-                throw new ValidationError(`Missing verifier at index ${siger.index}.`);
-            }
-            if (!verfer.verify(siger.raw, ser)) {
-                throw new ValidationError(`Signature ${siger.index + 1} is invalid.`);
-            }
-            console.log(`Signature ${siger.index + 1} is valid.`);
-        }
-    });
-}