stitchkit 0.93.0 → 0.94.1

package/dist/tools/cli-command.d.ts

@@ -1,70 +0,0 @@
-import type { ZodObject, ZodType, z } from 'zod';
-import type { CliRunOptions } from './cli-args.js';
-import type { CliWriters } from './cli-format.js';
-import { type ToolResult } from './execute.js';
-export interface CliCommandContext<TInput extends ZodObject> extends CliWriters {
-    input: z.output<TInput>;
-    options: Readonly<CliRunOptions>;
-    /**
-     * The application's own global options for this invocation, already validated
-     * against `CliConfig.globalOptions`. Empty when the CLI declares none. Typed
-     * loosely because a command is defined independently of the CLI it is mounted
-     * on — read it through the same schema the application declared.
-     */
-    globals: Readonly<Record<string, unknown>>;
-}
-export interface CliCommandDefinitionBase<TInput extends ZodObject> {
-    name: string;
-    description: string;
-    input: TInput;
-}
-export interface CliCommandDefinitionWithOutput<TInput extends ZodObject, TOutput extends ZodType> extends CliCommandDefinitionBase<TInput> {
-    output: TOutput;
-    handler: (context: CliCommandContext<TInput>) => z.output<TOutput> | Promise<z.output<TOutput>>;
-    /** Pure post-validation stdout presentation; returned bytes are written verbatim once. */
-    present?: (context: {
-        result: z.output<TOutput>;
-        options: Readonly<CliRunOptions>;
-    }) => string;
-    /** Process exit code for a successfully validated result. */
-    exitCode?: (result: z.output<TOutput>) => number;
-}
-export interface CliCommandDefinitionWithoutOutput<TInput extends ZodObject> extends CliCommandDefinitionBase<TInput> {
-    output?: never;
-    present?: never;
-    exitCode?: never;
-    handler: (context: CliCommandContext<TInput>) => void | Promise<void>;
-}
-export type CliCommandDefinition = CliCommandDefinitionWithOutput<ZodObject, ZodType> | CliCommandDefinitionWithoutOutput<ZodObject>;
-/** Typed identity helper for one transport-local executable command. */
-export declare function defineCliCommand<TInput extends ZodObject, TOutput extends ZodType>(definition: CliCommandDefinitionWithOutput<TInput, TOutput>): CliCommandDefinitionWithOutput<TInput, TOutput>;
-export declare function defineCliCommand<TInput extends ZodObject>(definition: CliCommandDefinitionWithoutOutput<TInput>): CliCommandDefinitionWithoutOutput<TInput>;
-export interface PreparedCliCommandEmission {
-    result: ToolResult;
-    presentation?: string;
-    successExitCode: number;
-}
-/**
- * Whether a native command yields a value at all.
- *
- * The two halves of `CliCommandDefinition` are not the same kind of thing: one
- * returns a validated result and lets the frame print it, the other prints
- * itself and returns nothing. Only the first can be executed somewhere that has
- * no stdout to print to — an in-process invocation, a stream of JSON lines —
- * and this is the test that decides it.
- */
-export declare function cliCommandReturnsResult(definition: CliCommandDefinition): definition is CliCommandDefinitionWithOutput<ZodObject, ZodType>;
-/**
- * The exit code a successful result earns, or a throw naming the offence.
- *
- * Shared, because a command run in process must exit-code identically to the
- * same command typed at a prompt; two copies of this rule would eventually
- * disagree and the divergence would show up as a script that branches wrong.
- */
-export declare function cliCommandSuccessExitCode(definition: CliCommandDefinition, data: unknown): number;
-/** Apply native-only presentation policy after canonical output validation. */
-export declare function prepareCliCommandEmission(definition: CliCommandDefinition, result: ToolResult, options: Readonly<CliRunOptions>): PreparedCliCommandEmission;
-export declare function cliCommandPresentationSchema(definition: CliCommandDefinition): Record<string, unknown>;
-/** Execute a CLI-only definition without inventing a tool operation identity. */
-export declare function executeCliCommand(definition: CliCommandDefinition, rawArgs: Record<string, unknown>, options: CliRunOptions, writers: CliWriters, coerceJson: boolean, globals?: Readonly<Record<string, unknown>>): Promise<ToolResult>;
-//# sourceMappingURL=cli-command.d.ts.map

package/dist/tools/cli-command.d.ts.map

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

package/dist/tools/cli-format.d.ts

@@ -1,49 +0,0 @@
-/**
- * Render a `ToolResult` for the CLI surface and map it to a process exit code.
- *
- * Output is JSON — the CLI's audience is agents (Skills via Bash), scripts and
- * `| jq`, for which structured JSON is the right shape, not a hand-formatted
- * table. The default is pretty-printed (indented, the same shape an MCP tool
- * returns); `--json` switches success and error records to one compact line.
- *
- * stdout is reserved for that result; an error goes to stderr as the same
- * model-facing `{ error, retryable, details, _hint }` object the MCP / agent transports
- * return (`formatToolError`), so a script can keep `2>/dev/null` clean while
- * still parsing a success.
- */
-import type { ErrorHintFn, ToolResult } from './execute.js';
-/** Map a `ToolResult.code` to a process exit code. */
-export type ExitCodeMap = Record<string, number>;
-/**
- * Conventional exit codes — `0` success, distinct non-zero per error class so a
- * script can branch on `$?`. Merged under any `CliConfig.exitCodes` override.
- */
-export declare const DEFAULT_EXIT_CODES: ExitCodeMap;
-export interface CliWriters {
-    stdout: (text: string) => void;
-    stderr: (text: string) => void;
-}
-export interface EmitOptions {
-    /** Compact single-line success/error JSON; otherwise pretty-printed. */
-    json: boolean;
-    toolName: string;
-    errorHint?: ErrorHintFn;
-    exitCodes?: ExitCodeMap;
-}
-/**
- * Write a result to the right stream and return the exit code. Success → JSON
- * on stdout (pretty by default, compact with `--json`), exit `0`. Failure → the
- * error JSON on stderr, exit per the code map (unknown code → `1`).
- */
-/**
- * The exit code a result earns, without writing anything.
- *
- * Extracted so a caller that runs an operation in process — a stdin loop, a
- * resumable batch — gets the SAME code the printed path gives, from the same
- * table, rather than re-deriving one from the error code and drifting. It was
- * computed inside `emitResult`, which meant the only way to learn it was to
- * print.
- */
-export declare function cliExitCode(result: ToolResult, exitCodes?: ExitCodeMap): number;
-export declare function emitResult(result: ToolResult, writers: CliWriters, opts: EmitOptions): number;
-//# sourceMappingURL=cli-format.d.ts.map

package/dist/tools/cli-format.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-format.d.ts","sourceRoot":"","sources":["../../src/tools/cli-format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGzD,sDAAsD;AACtD,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAWhC,CAAC;AAEF,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,SAAS,CAAC,EAAE,WAAW,CAAC;CACzB;AAED;;;;GAIG;AACH;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,WAAW,GAAG,MAAM,CAY/E;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,WAAW,GAChB,MAAM,CAeR"}

package/dist/tools/cli-installer.d.ts

@@ -1,34 +0,0 @@
-/**
- * Generate the one-line installer, from the manifest, on the server.
- *
- * A `curl … | sh` runs on a machine where nothing is installed yet — including
- * `jq`. An installer that fetches the manifest and parses it therefore fails on
- * exactly the machines it exists for. Generating the script *from* the manifest,
- * with the URL and the digest already substituted, removes the dependency: the
- * script downloads one file, checks one digest and renames it into place.
- */
-import type { CliBuildAsset, CliBuildManifest } from './cli-manifest.js';
-export interface CliInstallerConfig {
-    manifest: CliBuildManifest;
-    /**
-     * The asset this script installs. Omit it to render one script covering every
-     * asset in the manifest, selected by `uname` at run time — otherwise the
-     * dispatch is the one hand-written piece left in the install path, and every
-     * publisher writes the same `uname -s`/`uname -m` mapping from memory.
-     */
-    asset?: CliBuildAsset;
-    /** The name the binary takes on the PATH; defaults to the manifest name. */
-    binaryName?: string;
-    /** Default install directory; overridable by `INSTALL_DIR` at run time. */
-    installDir?: string;
-}
-/**
- * Render the installer for one asset.
- *
- * The three properties that matter, in the script rather than in a comment:
- * no JSON parsing, the digest is checked against the **decompressed** bytes, and
- * the final step is a rename — an interrupted download leaves a temporary file,
- * never a half-written executable on someone's PATH.
- */
-export declare function renderCliInstaller(config: CliInstallerConfig): string;
-//# sourceMappingURL=cli-installer.d.ts.map

package/dist/tools/cli-installer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-installer.d.ts","sourceRoot":"","sources":["../../src/tools/cli-installer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEtE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAOD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CA+ErE"}

package/dist/tools/cli-invoke.d.ts

@@ -1,143 +0,0 @@
-/**
- * Running one already-parsed operation, in this process.
- *
- * The most common way an agent drives a CLI is not one command — it is a
- * stream: a JSON line per operation, an answer per line. The framework owned
- * the parsing, the routing, the JSON mode, the exit codes and the error shape,
- * and handed out no way to say "run this parsed call and give me its result".
- * So a consumer's stream loop spawned the binary again per line: three
- * conversions of the same data (arguments back into `--flag value` strings,
- * nested objects through `JSON.stringify` into an argv slot, the result parsed
- * back out of stdout text) plus a process start each time — measured at 0.15 s,
- * which is thirty seconds for a two-hundred-line manifest before any work
- * happens. The ban on nesting one stream inside another existed for the same
- * reason and disappears with it.
- *
- * `createCliInvoker` compiles the managed surface once and executes against it.
- * `createCli` is built on this same function, so the stream and the command
- * line cannot answer differently: one surface, one runner, one exit table.
- *
- * Native commands (`config.commands`) are in it when, and only when, they
- * declare `output`. The two halves of a native definition are not the same kind
- * of thing: one returns a validated value the frame prints, the other prints
- * itself and returns `void`. Only the second cannot be run where there is no
- * stdout, and excluding both because of it cost a consumer a working `describe`
- * line for no reason the type could not already tell apart.
- *
- * `present` is not called on this path: it is stdout formatting, and there is
- * no stdout. `exitCode` is, through the same function the command line uses, so
- * a script branching on the code cannot see the two paths disagree. Anything
- * the handler does write is captured and returned on the result rather than
- * leaking into a caller's stream of answers.
- */
-import type { ZodObject, z } from 'zod';
-import type { ServiceDef, StitchLogger } from '../server/types.js';
-import { type CliCommandDefinition } from './cli-command.js';
-import { type ExitCodeMap } from './cli-format.js';
-import { type CliCommandPresentation, type CliPresentationPolicyConfig } from './cli-policy.js';
-import { type ErrorHintFn, type ToolCallHooks, type ToolLifecycle, type ToolResult } from './execute.js';
-import { type MountableTool } from './mount.js';
-import type { RuntimeToolDefinition } from './runtime-tool.js';
-export type CliSurfaceSource<TAuth, TValue> = readonly TValue[] | ((auth: Awaited<TAuth> | undefined) => readonly TValue[]);
-/**
- * What an invocation needs to exist: the surface, the identity behind it and
- * the policies every call runs under. Everything about a terminal — argv,
- * writers, `--wait`, downloads — belongs to `CliConfig`, which extends this.
- */
-export interface CliInvokerConfig<TAuth = unknown, TContext extends Record<string, unknown> = Record<string, unknown>, TGlobals extends ZodObject = ZodObject> extends CliPresentationPolicyConfig {
-    /** Program name — used in diagnostics. */
-    name: string;
-    /** Contract services exposed as commands — may depend on the resolved identity. */
-    services?: CliSurfaceSource<TAuth, ServiceDef>;
-    /** Pathless managed operations. CLI exposure always requires `transports: ['CLI']`. */
-    runtimeTools?: CliSurfaceSource<TAuth, RuntimeToolDefinition>;
-    /** CLI-only executable commands, dispatched before the managed surface. */
-    commands?: readonly CliCommandDefinition[];
-    auth?: TAuth | Promise<TAuth>;
-    resolveAuth?: (globals: z.output<TGlobals>) => TAuth | Promise<TAuth>;
-    globalOptions?: TGlobals;
-    context?: (auth: Awaited<TAuth> | undefined, globals: z.output<TGlobals>) => TContext;
-    signal?: AbortSignal;
-    hooks?: ToolCallHooks;
-    lifecycle?: ToolLifecycle;
-    logger?: StitchLogger;
-    coerceJsonArgs?: boolean;
-    errorHint?: ErrorHintFn;
-    exitCodes?: ExitCodeMap;
-    passthrough?: Record<string, string>;
-}
-/** What one parsed invocation produced — never printed, never exited on. */
-export interface CliInvocationResult {
-    ok: boolean;
-    /** The exit code the printed path would give this same result. */
-    exitCode: number;
-    /** The validated handler output, on success. */
-    data?: unknown;
-    /** The refusal, in the shape the CLI prints on failure. */
-    error?: {
-        code: string;
-        message: string;
-        details?: unknown;
-        hint?: string;
-        retryable?: boolean;
-    };
-    /**
-     * What a native handler wrote, when it wrote anything.
-     *
-     * A command that declares `output` is not supposed to write — the frame
-     * prints for it — but it holds the writers and may log. In process there is
-     * nowhere for that text to go: printing it would interleave with a caller's
-     * own output and corrupt a stream of JSON lines, and dropping it would lose a
-     * diagnostic silently. So it comes back here, and the caller decides.
-     */
-    written?: {
-        stdout?: string;
-        stderr?: string;
-    };
-}
-/** One resolved managed command. */
-export interface CliInvokerCommand {
-    name: string;
-    description: string;
-}
-/** The compiled surface: what can be run, and how to run it. */
-export interface CliInvoker {
-    /** Every managed command, in surface order. */
-    readonly commands: readonly CliInvokerCommand[];
-    /**
-     * Run one parsed call. Never writes, never exits. An unknown command is a
-     * `NOT_FOUND` result rather than a throw, because a stream must answer the
-     * line that was wrong and keep reading the ones that follow.
-     */
-    invoke(command: string, args: Record<string, unknown>): Promise<CliInvocationResult>;
-}
-/**
- * Shape a `ToolResult` into an invocation result — the same error body the CLI
- * prints, and the same exit code, produced without printing either.
- */
-export declare function cliInvocationResult(result: ToolResult, toolName: string, config: {
-    errorHint?: ErrorHintFn;
-    exitCodes?: ExitCodeMap;
-}): CliInvocationResult;
-/**
- * Compile the managed surface and return a dispatcher over it.
- *
- * Identity resolves once, not per call: a stream of two hundred operations must
- * not resolve auth two hundred times, and a CLI invocation speaks as one
- * identity by construction.
- */
-export declare function createCliInvoker<TAuth = unknown, TContext extends Record<string, unknown> = Record<string, unknown>, TGlobals extends ZodObject = ZodObject>(config: CliInvokerConfig<TAuth, TContext, TGlobals>, globals?: Record<string, unknown>): Promise<CliInvoker>;
-/**
- * Walk the declared surface into executable tools and their presentation.
- *
- * Shared with `createCli`, which starts from its native commands rather than an
- * empty map — the uniqueness and shape checks have to see both halves, or a
- * managed command could silently shadow a native one.
- */
-export declare function buildCliSurface<TAuth, TContext extends Record<string, unknown>, TGlobals extends ZodObject>(config: CliInvokerConfig<TAuth, TContext, TGlobals>, auth: Awaited<TAuth> | undefined, nativeHelp: Map<string, CliCommandPresentation>, applicationGlobalNames: ReadonlySet<string>, assertShape?: (name: string, descriptor: CliCommandPresentation, exists: boolean, passthroughField: string | undefined, globalNames: ReadonlySet<string>) => void): {
-    tools: Map<string, MountableTool>;
-    help: Map<string, CliCommandPresentation>;
-};
-/** How a managed tool presents itself — the same shape a native command builds. */
-export declare function managedCliDescriptor(tool: MountableTool): Omit<CliCommandPresentation, 'aliases' | 'positionals'>;
-//# sourceMappingURL=cli-invoke.d.ts.map

package/dist/tools/cli-invoke.d.ts.map

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

package/dist/tools/cli-manifest.d.ts

@@ -1,80 +0,0 @@
-/**
- * The build manifest a CLI is distributed by — one schema, so the publisher,
- * the server and the installed binary cannot disagree about it.
- *
- * Everything here is Zod and arithmetic: no filesystem, no network. The half
- * that downloads lives in `cli-update.ts`, the half that writes shell in
- * `cli-installer.ts`, and both read these shapes.
- */
-import { z } from 'zod';
-/** What a build runs on. The values are Node's own, so a CLI can name its own. */
-export declare const CliBuildTargetSchema: z.ZodObject<{
-    platform: z.ZodString;
-    arch: z.ZodString;
-}, z.core.$strip>;
-export type CliBuildTarget = z.infer<typeof CliBuildTargetSchema>;
-/**
- * One downloadable build.
- *
- * `size` and `sha256` describe the **decompressed** bytes — what will actually
- * be executed. A digest over the transferred archive proves the transfer and
- * says nothing about the file that ends up on the PATH, which is the one the
- * user runs.
- */
-export declare const CliBuildAssetSchema: z.ZodObject<{
-    platform: z.ZodString;
-    arch: z.ZodString;
-    url: z.ZodURL;
-    compression: z.ZodDefault<z.ZodEnum<{
-        gzip: "gzip";
-        none: "none";
-    }>>;
-    size: z.ZodInt;
-    sha256: z.ZodString;
-}, z.core.$strip>;
-export type CliBuildAsset = z.infer<typeof CliBuildAssetSchema>;
-/**
- * The document a CLI's distribution endpoint serves.
- *
- * `commit` and `builtAt` are here, not only inside the binary, because the
- * question "is what I am running the build this version means" is asked from
- * both sides.
- */
-export declare const CliBuildManifestSchema: z.ZodObject<{
-    name: z.ZodString;
-    version: z.ZodString;
-    commit: z.ZodString;
-    builtAt: z.ZodISODateTime;
-    assets: z.ZodArray<z.ZodObject<{
-        platform: z.ZodString;
-        arch: z.ZodString;
-        url: z.ZodURL;
-        compression: z.ZodDefault<z.ZodEnum<{
-            gzip: "gzip";
-            none: "none";
-        }>>;
-        size: z.ZodInt;
-        sha256: z.ZodString;
-    }, z.core.$strip>>;
-    signature: z.ZodOptional<z.ZodObject<{
-        algorithm: z.ZodLiteral<"ed25519">;
-        keyId: z.ZodString;
-        signature: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type CliBuildManifest = z.infer<typeof CliBuildManifestSchema>;
-/** The stamp a build carries inside itself, so the tool can say what it is. */
-export declare const CliBuildStampSchema: z.ZodObject<{
-    version: z.ZodString;
-    commit: z.ZodString;
-    builtAt: z.ZodISODateTime;
-}, z.core.$strip>;
-export type CliBuildStamp = z.infer<typeof CliBuildStampSchema>;
-/** One line a `--version` can print: what it is, not what the reader infers. */
-export declare function formatCliBuildStamp(stamp: CliBuildStamp, name?: string): string;
-/** The target the running process is on, in the manifest's own vocabulary. */
-export declare function currentCliBuildTarget(): CliBuildTarget;
-/** The asset for one target, or `undefined` when this build was not published. */
-export declare function selectCliBuildAsset(manifest: CliBuildManifest, target?: CliBuildTarget): CliBuildAsset | undefined;
-export declare function assertCliPublishable(previous: CliBuildManifest | readonly CliBuildManifest[] | undefined, next: CliBuildManifest): void;
-//# sourceMappingURL=cli-manifest.d.ts.map

package/dist/tools/cli-manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-manifest.d.ts","sourceRoot":"","sources":["../../src/tools/cli-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,kFAAkF;AAClF,eAAO,MAAM,oBAAoB;;;iBAG/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;iBAK9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;iBAejC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB;;;;iBAI9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAG/E;AAED,8EAA8E;AAC9E,wBAAgB,qBAAqB,IAAI,cAAc,CAEtD;AAED,kFAAkF;AAClF,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,GAAE,cAAwC,GAC/C,aAAa,GAAG,SAAS,CAI3B;AAgBD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,GAAG,SAAS,gBAAgB,EAAE,GAAG,SAAS,EACpE,IAAI,EAAE,gBAAgB,GACrB,IAAI,CAkBN"}

package/dist/tools/cli-policy.d.ts

@@ -1,27 +0,0 @@
-import { describeSchemaFields } from './cli-args.js';
-export interface CliPresentationPolicyConfig {
-    /** Command selected when argv contains no explicit command. */
-    defaultCommand?: string;
-    /** Exact command-scoped short option aliases (`{ logs: { f: 'follow' } }`). */
-    optionAliases?: Readonly<Record<string, Readonly<Record<string, string>>>>;
-    /** Exact ordered argv-positional fields per command; an empty array disables positionals. */
-    positionals?: Readonly<Record<string, readonly string[]>>;
-}
-export interface CliCommandPresentation {
-    description: string;
-    argumentSchema: Parameters<typeof describeSchemaFields>[0];
-    presentationSchema: Record<string, unknown>;
-    /** Canonical field name → one short alias. */
-    aliases: ReadonlyMap<string, string>;
-    /**
-     * `undefined` retains automatic non-boolean schema order. A trailing ARRAY
-     * field is variadic — it takes every remaining token. An array declared
-     * anywhere else keeps taking exactly one (a JSON-array token), and command
-     * help says which is which: only the variadic tail renders as `<name...>`.
-     */
-    positionals?: readonly string[];
-}
-export declare function applyCliPresentationPolicy(command: string, descriptor: Omit<CliCommandPresentation, 'aliases' | 'positionals'>, config: CliPresentationPolicyConfig): CliCommandPresentation;
-/** Validate name-keyed policies only when the complete managed surface has resolved. */
-export declare function assertCliPoliciesResolved(commands: ReadonlyMap<string, CliCommandPresentation>, config: CliPresentationPolicyConfig): void;
-//# sourceMappingURL=cli-policy.d.ts.map

package/dist/tools/cli-policy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-policy.d.ts","sourceRoot":"","sources":["../../src/tools/cli-policy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGlD,MAAM,WAAW,2BAA2B;IAC1C,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,6FAA6F;IAC7F,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3D,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,8CAA8C;IAC9C,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAkFD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,IAAI,CAAC,sBAAsB,EAAE,SAAS,GAAG,aAAa,CAAC,EACnE,MAAM,EAAE,2BAA2B,GAClC,sBAAsB,CAexB;AAED,wFAAwF;AACxF,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,EACrD,MAAM,EAAE,2BAA2B,GAClC,IAAI,CAWN"}

package/dist/tools/cli-profile.d.ts

@@ -1,40 +0,0 @@
-import type { z } from 'zod';
-import { AppError } from '../contract/errors.js';
-/** A refusal a CLI can report as an ordinary error result. */
-export declare class CliProfileError extends AppError {
-    constructor(message: string, code?: 'NOT_FOUND' | 'BAD_REQUEST' | 'FORBIDDEN');
-}
-export interface CliProfileStoreConfig<TSchema extends z.ZodType> {
-    /** Directory holding one `<name>.json` per profile, mode 0700. */
-    directory: string;
-    /** What one profile file must contain — an address and a credential, typically. */
-    schema: TSchema;
-    /**
-     * How to create a missing profile, in the application's own words. It is
-     * printed with the refusal, because "profile not found" without the command
-     * that creates it leaves the reader to guess the file format.
-     */
-    createHint?: (name: string, path: string) => string;
-    /** Where the substitution notice goes; default stderr. */
-    announce?: (line: string) => void;
-}
-export interface ResolvedCliProfile<TValue> {
-    name: string;
-    path: string;
-    value: TValue;
-    /** True when no name was asked for and the only configured profile was taken. */
-    substituted: boolean;
-}
-export interface CliProfileStore<TValue> {
-    directory: string;
-    pathFor(name: string): string;
-    list(): string[];
-    read(name: string): TValue;
-    /** Write a profile, creating the directory 0700 and the file 0600. */
-    write(name: string, value: unknown): string;
-    /** The rule this module exists for. `undefined` means "no name was given". */
-    resolve(name: string | undefined): ResolvedCliProfile<TValue>;
-}
-/** Build a profile store over a directory of `0600` JSON files. */
-export declare function createCliProfileStore<TSchema extends z.ZodType>(config: CliProfileStoreConfig<TSchema>): CliProfileStore<z.output<TSchema>>;
-//# sourceMappingURL=cli-profile.d.ts.map

package/dist/tools/cli-profile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-profile.d.ts","sourceRoot":"","sources":["../../src/tools/cli-profile.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAO9C,8DAA8D;AAC9D,qBAAa,eAAgB,SAAQ,QAAQ;IAC3C,YAAY,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,WAAW,GAAG,aAAa,GAAG,WAAyB,EAGzF;CACF;AAED,MAAM,WAAW,qBAAqB,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO;IAC9D,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,MAAM,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACpD,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,kBAAkB,CAAC,MAAM;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,eAAe,CAAC,MAAM;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,sEAAsE;IACtE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IAC5C,8EAA8E;IAC9E,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;CAC/D;AAWD,mEAAmE;AACnE,wBAAgB,qBAAqB,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO,EAC7D,MAAM,EAAE,qBAAqB,CAAC,OAAO,CAAC,GACrC,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAqFpC"}

package/dist/tools/cli-signature.d.ts

@@ -1,81 +0,0 @@
-/**
- * Who built the binary — which the asset digest cannot answer.
- *
- * The digest proves the bytes that arrived are the bytes the manifest named. It
- * proves nothing about who named them: the manifest and the assets come from
- * one origin, and whoever can replace one can replace the other. Authorship
- * needs a key the build carries and the server never holds.
- *
- * So the signature covers the manifest's identity AND every asset's digest —
- * `{name, version, commit, builtAt, assets[]}` — and the chain closes on the
- * file that will execute rather than on the document describing it. Signing the
- * document alone would leave an attacker free to swap an asset URL's contents
- * and keep a valid signature over an unchanged document.
- *
- * Ed25519 over `node:crypto`; no dependency is added for this.
- */
-import { z } from 'zod';
-import type { CliBuildManifest } from './cli-manifest.js';
-/** The detached signature a published manifest carries beside its own fields. */
-export declare const CliBuildSignatureSchema: z.ZodObject<{
-    algorithm: z.ZodLiteral<"ed25519">;
-    keyId: z.ZodString;
-    signature: z.ZodString;
-}, z.core.$strip>;
-export type CliBuildSignature = z.infer<typeof CliBuildSignatureSchema>;
-/**
- * What a verification concluded. Five answers, and `unenforced` is the one that
- * earns its keep: a build with no pinned key must keep updating, and the fact
- * that nothing was checked has to be VISIBLE rather than assumed. A silent
- * "fine" from a check that never ran is the failure mode this whole file exists
- * to remove.
- */
-export type CliSignatureVerdict = 'valid' | 'unenforced' | 'missing' | 'unknown-key' | 'invalid';
-/** The keys a build trusts, by id. A build with none enforces nothing. */
-export interface CliTrustRoot {
-    /**
-     * `keyId` → public key, as SPKI PEM or base64 of the raw 32-byte Ed25519 key.
-     * Compiled into the binary: a trust root fetched at runtime from the same
-     * origin as the manifest proves nothing.
-     */
-    keys: Readonly<Record<string, string>>;
-}
-/**
- * The exact bytes a signature covers.
- *
- * Canonical JSON, so two producers that agree on the content agree on the
- * bytes — key order and whitespace are not allowed to decide whether a
- * signature verifies. Every asset contributes its target, its compression, its
- * size and its digest; `url` does not, because where a file is served from is
- * the publisher's business and moving it must not invalidate the proof of what
- * it contains. Everything that decides what happens to the bytes BEFORE the
- * digest can be checked is signed; only the address is free.
- */
-export declare function cliManifestSigningPayload(manifest: CliBuildManifest): string;
-/**
- * A private key as it comes out of a file or a secret store: PEM text, or DER
- * bytes.
- *
- * Deliberately not `KeyObject`. That type belongs to `node:crypto`, and naming
- * it in a published signature puts `import("node:crypto")` into the declaration
- * files of a package whose browser-safe entries a consumer resolves without
- * Node types at all — the whole surface stops typechecking for them over a
- * function they never call.
- */
-export type CliSigningKey = string | Uint8Array;
-/** Sign a manifest — for the publisher, which is the only side that holds a key. */
-export declare function signCliManifest(manifest: CliBuildManifest, options: {
-    keyId: string;
-    privateKey: CliSigningKey;
-}): CliBuildSignature;
-/**
- * Verify a manifest against the build's own trust root.
- *
- * Never throws: a verdict is the answer, including for a malformed key or a
- * signature that is not base64 at all. A caller deciding whether to download
- * something wants a decision, not an exception to translate into one.
- */
-export declare function verifyCliManifest(manifest: CliBuildManifest, signature: CliBuildSignature | undefined, trust?: CliTrustRoot): CliSignatureVerdict;
-/** Whether a verdict permits installing the build it describes. */
-export declare function cliSignatureAccepted(verdict: CliSignatureVerdict): boolean;
-//# sourceMappingURL=cli-signature.d.ts.map

package/dist/tools/cli-signature.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-signature.d.ts","sourceRoot":"","sources":["../../src/tools/cli-signature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AASH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,iFAAiF;AACjF,eAAO,MAAM,uBAAuB;;;;iBAMlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAC3B,OAAO,GACP,YAAY,GACZ,SAAS,GACT,aAAa,GACb,SAAS,CAAC;AAEd,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAkB5E;AAgBD;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,UAAU,CAAC;AAEhD,oFAAoF;AACpF,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,aAAa,CAAA;CAAE,GACpD,iBAAiB,CAenB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,EAAE,iBAAiB,GAAG,SAAS,EACxC,KAAK,CAAC,EAAE,YAAY,GACnB,mBAAmB,CAiBrB;AAED,mEAAmE;AACnE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAE1E"}