@jini-ai/cli 0.3.1 → 0.4.1

package/dist/run-command.js

@@ -14,59 +14,38 @@
  * Every network call goes through this package's already-hardened
  * `postJsonToDaemon`/`getJsonFromDaemon` (bounded timeout, response-size cap,
  * structured-error mapping, redaction) — nothing here re-implements that.
- * `run watch`'s SSE consumption is new (this package's own `source-map.md`
+ * `run watch`'s SSE consumption is new (this package's own `archived provenance ledger`
  * calls the mechanics — GET an SSE endpoint, translate frames to one NDJSON
  * line per event on stdout, stop at a terminal `'end'` event — a clean
  * pattern that had no route to call until now).
  */
+import { decodeSseFrames } from '@jini-ai/core/primitives';
 import { parseFlags, positionalArgs } from './flags.js';
 import { exitWithStructuredError, structuredHttpFailure } from './errors.js';
 import { getJsonFromDaemon, postJsonToDaemon } from './http.js';
-import { sanitizeUntrustedText, stripControlSequences } from './redact.js';
+import { sanitizeUntrustedText, stripControlSequences } from '@jini-ai/core/text';
 import { renderUsage } from './usage.js';
-function defaultWrite(text) {
+function defaultWrite({ text }) {
     process.stdout.write(text);
 }
-function defaultWriteErr(text) {
+function defaultWriteErr({ text }) {
     process.stderr.write(text);
 }
-const RUN_START_USAGE = renderUsage({
-    usage: ['run start --context-ref <ref> [--agent-id <id>] [--idempotency-key <key>]'],
-    description: 'Starts a new run for the given contextRef.',
-    options: [
+const RUN_START_USAGE = renderUsage({ usage: ['run start --context-ref <ref> [--agent-id <id>] [--idempotency-key <key>]'] }, { description: 'Starts a new run for the given contextRef.', options: [
         { flag: '--context-ref', description: 'Opaque caller-supplied identity the run belongs to (required).' },
         { flag: '--agent-id', description: 'Which registered agent should drive this run.' },
         { flag: '--idempotency-key', description: 'Starting twice with the same key returns the original run.' },
-    ],
-});
-const RUN_LIST_USAGE = renderUsage({
-    usage: ['run list [--context-ref <ref>]'],
-    description: 'Lists runs, optionally scoped to a contextRef.',
-    options: [{ flag: '--context-ref', description: 'Only list runs belonging to this contextRef.' }],
-});
-const RUN_GET_USAGE = renderUsage({
-    usage: ['run get <runId>'],
-    description: 'Fetches a single run by id.',
-});
-const RUN_CANCEL_USAGE = renderUsage({
-    usage: ['run cancel <runId> [--reason <text>]'],
-    description: 'Requests cancellation of an in-progress run. A no-op on an already-terminal run.',
-    options: [{ flag: '--reason', description: 'Optional human-readable cancellation reason.' }],
-});
-const RUN_WATCH_USAGE = renderUsage({
-    usage: ['run watch <runId> [--after-cursor <cursor>]'],
-    description: 'Streams a run\'s protocol events as one NDJSON line per event on stdout until a terminal event arrives.',
-    options: [{ flag: '--after-cursor', description: 'Resume streaming after this event cursor (reconnect support).' }],
-});
-const RUN_USAGE = renderUsage({
-    usage: ['run <start|list|get|cancel|watch> ...'],
-    description: 'Manage runs against a Jini daemon over HTTP.',
-});
+    ] });
+const RUN_LIST_USAGE = renderUsage({ usage: ['run list [--context-ref <ref>]'] }, { description: 'Lists runs, optionally scoped to a contextRef.', options: [{ flag: '--context-ref', description: 'Only list runs belonging to this contextRef.' }] });
+const RUN_GET_USAGE = renderUsage({ usage: ['run get <runId>'] }, { description: 'Fetches a single run by id.' });
+const RUN_CANCEL_USAGE = renderUsage({ usage: ['run cancel <runId> [--reason <text>]'] }, { description: 'Requests cancellation of an in-progress run. A no-op on an already-terminal run.', options: [{ flag: '--reason', description: 'Optional human-readable cancellation reason.' }] });
+const RUN_WATCH_USAGE = renderUsage({ usage: ['run watch <runId> [--after-cursor <cursor>]'] }, { description: 'Streams a run\'s protocol events as one NDJSON line per event on stdout until a terminal event arrives.', options: [{ flag: '--after-cursor', description: 'Resume streaming after this event cursor (reconnect support).' }] });
+const RUN_USAGE = renderUsage({ usage: ['run <start|list|get|cancel|watch> ...'] }, { description: 'Manage runs against a Jini daemon over HTTP.' });
 /** Builds `{write, exit, exitCodes?}` for `errors.ts`'s structured-error helpers, never assigning `exitCodes` when unset (required under `exactOptionalPropertyTypes`). */
 function errorOptions(deps) {
     return {
         write: deps.writeErr ?? defaultWriteErr,
-        exit: deps.exit ?? ((code) => process.exit(code)),
+        exit: deps.exit ?? (({ code }) => process.exit(code)),
         ...(deps.exitCodes !== undefined ? { exitCodes: deps.exitCodes } : {}),
     };
 }
@@ -86,18 +65,19 @@ function invalidFlag(deps, message) {
     return exitWithStructuredError({ code: 'invalid-flag', message }, errorOptions(deps));
 }
 function printJsonResult(deps, value) {
-    (deps.write ?? defaultWrite)(`${JSON.stringify(value)}\n`);
+    (deps.write ?? defaultWrite)({ text: `${JSON.stringify(value)}\n` });
 }
 async function resolveBaseUrl(deps) {
     return deps.resolveBaseUrl();
 }
 /** `run start --context-ref <ref> [--agent-id <id>] [--idempotency-key <key>]` */
-export async function runStartCommand(args, deps) {
+export async function runStartCommand({ args, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs = {}) {
+    const deps = { resolveBaseUrl: resolveBaseUrlPort, ...optionalArgs };
     if (args.includes('--help') || args.includes('-h')) {
-        (deps.write ?? defaultWrite)(`${RUN_START_USAGE}\n`);
+        (deps.write ?? defaultWrite)({ text: `${RUN_START_USAGE}\n` });
         return;
     }
-    const flags = parseFlags(args, { string: new Set(['context-ref', 'agent-id', 'idempotency-key']) });
+    const flags = parseFlags({ argv: args }, { string: new Set(['context-ref', 'agent-id', 'idempotency-key']) });
     const contextRef = flags['context-ref'];
     if (typeof contextRef !== 'string' || contextRef.length === 0) {
         missingInput(deps, '--context-ref is required');
@@ -108,46 +88,49 @@ export async function runStartCommand(args, deps) {
     if (typeof flags['idempotency-key'] === 'string')
         body.idempotencyKey = flags['idempotency-key'];
     const baseUrl = await resolveBaseUrl(deps);
-    const result = await postJsonToDaemon(baseUrl, '/api/runs', body, transportOptions(deps));
+    const result = await postJsonToDaemon({ base: baseUrl, route: '/api/runs', body }, transportOptions(deps));
     printJsonResult(deps, result);
 }
 /** `run list [--context-ref <ref>]` */
-export async function runListCommand(args, deps) {
+export async function runListCommand({ args, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs = {}) {
+    const deps = { resolveBaseUrl: resolveBaseUrlPort, ...optionalArgs };
     if (args.includes('--help') || args.includes('-h')) {
-        (deps.write ?? defaultWrite)(`${RUN_LIST_USAGE}\n`);
+        (deps.write ?? defaultWrite)({ text: `${RUN_LIST_USAGE}\n` });
         return;
     }
-    const flags = parseFlags(args, { string: new Set(['context-ref']) });
+    const flags = parseFlags({ argv: args }, { string: new Set(['context-ref']) });
     const contextRef = flags['context-ref'];
     const route = typeof contextRef === 'string' && contextRef.length > 0
         ? `/api/runs?contextRef=${encodeURIComponent(contextRef)}`
         : '/api/runs';
     const baseUrl = await resolveBaseUrl(deps);
-    const result = await getJsonFromDaemon(baseUrl, route, transportOptions(deps));
+    const result = await getJsonFromDaemon({ base: baseUrl, route }, transportOptions(deps));
     printJsonResult(deps, result);
 }
 /** `run get <runId>` */
-export async function runGetCommand(args, deps) {
+export async function runGetCommand({ args, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs = {}) {
+    const deps = { resolveBaseUrl: resolveBaseUrlPort, ...optionalArgs };
     if (args.includes('--help') || args.includes('-h')) {
-        (deps.write ?? defaultWrite)(`${RUN_GET_USAGE}\n`);
+        (deps.write ?? defaultWrite)({ text: `${RUN_GET_USAGE}\n` });
         return;
     }
-    const runId = positionalArgs(args)[0];
+    const runId = positionalArgs({ argv: args })[0];
     if (typeof runId !== 'string' || runId.length === 0) {
         missingInput(deps, 'runId is required: run get <runId>');
     }
     const baseUrl = await resolveBaseUrl(deps);
-    const result = await getJsonFromDaemon(baseUrl, `/api/runs/${encodeURIComponent(runId)}`, transportOptions(deps));
+    const result = await getJsonFromDaemon({ base: baseUrl, route: `/api/runs/${encodeURIComponent(runId)}` }, transportOptions(deps));
     printJsonResult(deps, result);
 }
 /** `run cancel <runId> [--reason <text>]` */
-export async function runCancelCommand(args, deps) {
+export async function runCancelCommand({ args, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs = {}) {
+    const deps = { resolveBaseUrl: resolveBaseUrlPort, ...optionalArgs };
     if (args.includes('--help') || args.includes('-h')) {
-        (deps.write ?? defaultWrite)(`${RUN_CANCEL_USAGE}\n`);
+        (deps.write ?? defaultWrite)({ text: `${RUN_CANCEL_USAGE}\n` });
         return;
     }
-    const flags = parseFlags(args, { string: new Set(['reason']) });
-    const runId = positionalArgs(args, { string: new Set(['reason']) })[0];
+    const flags = parseFlags({ argv: args }, { string: new Set(['reason']) });
+    const runId = positionalArgs({ argv: args }, { string: new Set(['reason']) })[0];
     if (typeof runId !== 'string' || runId.length === 0) {
         missingInput(deps, 'runId is required: run cancel <runId>');
     }
@@ -155,50 +138,31 @@ export async function runCancelCommand(args, deps) {
     if (typeof flags.reason === 'string')
         body.reason = flags.reason;
     const baseUrl = await resolveBaseUrl(deps);
-    const result = await postJsonToDaemon(baseUrl, `/api/runs/${encodeURIComponent(runId)}/cancel`, body, transportOptions(deps));
+    const result = await postJsonToDaemon({ base: baseUrl, route: `/api/runs/${encodeURIComponent(runId)}/cancel`, body }, transportOptions(deps));
     printJsonResult(deps, result);
 }
-/** Cap on total buffered-but-not-yet-frame-terminated SSE bytes — a daemon that never sends a blank-line frame terminator must not grow this without bound (mirrors `http.ts`'s `readJsonWithLimit` byte cap). */
-const MAX_SSE_BUFFER_BYTES = 10 * 1024 * 1024;
-function parseSseFrame(rawFrame) {
-    let id;
-    let eventName;
-    const dataLines = [];
-    for (const line of rawFrame.split('\n')) {
-        if (line.startsWith('id: '))
-            id = line.slice(4);
-        else if (line.startsWith('event: '))
-            eventName = line.slice(7);
-        else if (line.startsWith('data: '))
-            dataLines.push(line.slice(6));
-    }
-    if (dataLines.length === 0)
-        return null;
-    return { ...(id !== undefined ? { id } : {}), ...(eventName !== undefined ? { event: eventName } : {}), data: dataLines.join('\n') };
-}
-/** Reads `body` as an SSE byte stream and yields one {@link SseFrame} per blank-line-terminated frame. */
+/** Cap on total buffered-but-not-yet-frame-terminated SSE text — a daemon that never sends a blank-line frame terminator must not grow this without bound (retains the historical 10 MiB-sized text cap; TextDecoder output is measured in UTF-16 units). */
+const MAX_SSE_BUFFER_CHARS = 10 * 1024 * 1024;
+/** Reads complete records; this adapter releases the lock without canceling the host's body. */
 async function* readSseFrames(body) {
     const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    try {
+    async function* chunks() {
         for (;;) {
             const { done, value } = await reader.read();
             if (done)
-                break;
+                return;
             if (value !== undefined)
-                buffer += decoder.decode(value, { stream: true });
-            if (buffer.length > MAX_SSE_BUFFER_BYTES) {
-                throw new Error(`SSE stream exceeded the ${MAX_SSE_BUFFER_BYTES}-byte unterminated-frame buffer limit`);
-            }
-            let sepIndex;
-            while ((sepIndex = buffer.indexOf('\n\n')) >= 0) {
-                const rawFrame = buffer.slice(0, sepIndex);
-                buffer = buffer.slice(sepIndex + 2);
-                const frame = parseSseFrame(rawFrame);
-                if (frame !== null)
-                    yield frame;
-            }
+                yield value;
+        }
+    }
+    try {
+        for await (const frame of decodeSseFrames({ source: chunks() }, {
+            flushFinalFrame: false, maxBufferChars: MAX_SSE_BUFFER_CHARS,
+        })) {
+            if (frame.dataLines.length === 0)
+                continue;
+            yield { ...(frame.id !== undefined ? { id: frame.id } : {}),
+                ...(frame.event !== null ? { event: frame.event } : {}), data: frame.data };
         }
     }
     finally {
@@ -224,8 +188,8 @@ function isTerminalEventFrame(frame) {
  * the way a diagnostic error message is, since it is the run's actual event payload, not incidental
  * error detail.
  */
-export async function watchRunEvents(baseUrl, runId, args, deps) {
-    const flags = parseFlags(args, { string: new Set(['after-cursor']) });
+export async function watchRunEvents({ baseUrl, runId, args }, deps = {}) {
+    const flags = parseFlags({ argv: args }, { string: new Set(['after-cursor']) });
     const afterCursor = flags['after-cursor'];
     const fetchImpl = deps.fetchImpl ?? fetch;
     const write = deps.write ?? defaultWrite;
@@ -234,11 +198,11 @@ export async function watchRunEvents(baseUrl, runId, args, deps) {
         headers['last-event-id'] = afterCursor;
     const resp = await fetchImpl(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/events`, { headers });
     if (!resp.ok || resp.body === null) {
-        return structuredHttpFailure(resp, 'daemon-not-running', errorOptions(deps));
+        return structuredHttpFailure({ resp }, { fallbackCode: 'daemon-not-running', ...errorOptions(deps) });
     }
     try {
         for await (const frame of readSseFrames(resp.body)) {
-            write(`${stripControlSequences(frame.data)}\n`);
+            write({ text: `${stripControlSequences({ text: frame.data })}\n` });
             if (isTerminalEventFrame(frame))
                 return;
         }
@@ -247,45 +211,47 @@ export async function watchRunEvents(baseUrl, runId, args, deps) {
         // A broken/hostile stream (e.g. the unbounded-buffer guard above) must exit through the same
         // structured contract as every other failure here, not surface as an unhandled rejection.
         const message = error instanceof Error ? error.message : String(error);
-        return exitWithStructuredError({ code: 'daemon-not-running', message: sanitizeUntrustedText(message) }, errorOptions(deps));
+        return exitWithStructuredError({ code: 'daemon-not-running', message: sanitizeUntrustedText({ text: message }) }, errorOptions(deps));
     }
 }
 /** `run watch <runId> [--after-cursor <cursor>]` */
-export async function runWatchCommand(args, deps) {
+export async function runWatchCommand({ args, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs = {}) {
+    const deps = { resolveBaseUrl: resolveBaseUrlPort, ...optionalArgs };
     if (args.includes('--help') || args.includes('-h')) {
-        (deps.write ?? defaultWrite)(`${RUN_WATCH_USAGE}\n`);
+        (deps.write ?? defaultWrite)({ text: `${RUN_WATCH_USAGE}\n` });
         return;
     }
-    const runId = positionalArgs(args, { string: new Set(['after-cursor']) })[0];
+    const runId = positionalArgs({ argv: args }, { string: new Set(['after-cursor']) })[0];
     if (typeof runId !== 'string' || runId.length === 0) {
         missingInput(deps, 'runId is required: run watch <runId>');
     }
     const baseUrl = await resolveBaseUrl(deps);
-    await watchRunEvents(baseUrl, runId, args, deps);
+    await watchRunEvents({ baseUrl, runId, args }, deps);
 }
 /** Registers `run` (dispatching `start`/`list`/`cancel`/`watch` on the first remaining token) against `registry`. */
-export function registerRunCommands(registry, deps) {
-    registry.add('run', async (args) => {
-        const [sub, ...rest] = args;
-        switch (sub) {
-            case 'start':
-                return runStartCommand(rest, deps);
-            case 'list':
-                return runListCommand(rest, deps);
-            case 'get':
-                return runGetCommand(rest, deps);
-            case 'cancel':
-                return runCancelCommand(rest, deps);
-            case 'watch':
-                return runWatchCommand(rest, deps);
-            case undefined:
-            case '--help':
-            case '-h':
-                (deps.write ?? defaultWrite)(`${RUN_USAGE}\n`);
-                return;
-            default:
-                invalidFlag(deps, `unknown "run" subcommand: ${sub}`);
-        }
-    }, { usage: RUN_USAGE });
+export function registerRunCommands({ registry, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs = {}) {
+    const deps = { resolveBaseUrl: resolveBaseUrlPort, ...optionalArgs };
+    registry.add({ name: 'run', handler: async ({ args }) => {
+            const [sub, ...rest] = args;
+            switch (sub) {
+                case 'start':
+                    return runStartCommand({ args: rest, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs);
+                case 'list':
+                    return runListCommand({ args: rest, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs);
+                case 'get':
+                    return runGetCommand({ args: rest, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs);
+                case 'cancel':
+                    return runCancelCommand({ args: rest, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs);
+                case 'watch':
+                    return runWatchCommand({ args: rest, resolveBaseUrl: resolveBaseUrlPort }, optionalArgs);
+                case undefined:
+                case '--help':
+                case '-h':
+                    (deps.write ?? defaultWrite)({ text: `${RUN_USAGE}\n` });
+                    return;
+                default:
+                    invalidFlag(deps, `unknown "run" subcommand: ${sub}`);
+            }
+        } }, { usage: RUN_USAGE });
 }
 //# sourceMappingURL=run-command.js.map

package/dist/tokens.js

@@ -8,5 +8,5 @@
  * subcommands against.
  */
 import { token } from '@jini-ai/core';
-export const CommandRegistryToken = token('jini.cli.commandRegistry');
+export const CommandRegistryToken = token({ id: 'jini.cli.commandRegistry' });
 //# sourceMappingURL=tokens.js.map

package/dist/usage.d.ts

@@ -2,7 +2,7 @@
  * @module usage
  *
  * The generic *shape* of every OD `print*Help` function, extracted from
- * `apps/daemon/src/cli.ts` (see `source-map.md`): one or more usage
+ * `apps/daemon/src/cli.ts` (see `archived provenance ledger`): one or more usage
  * invocation lines, an optional prose description, and an optional flat
  * list of `--option` descriptions. OD's actual help text is 100% product
  * content and was not ported — only the rendering convention.
@@ -14,11 +14,13 @@ export interface UsageOption {
 export interface UsageSpec {
     /** One or more `cmd sub <arg>` invocation lines. */
     usage: readonly string[];
+}
+export interface UsageOptions {
     /** Optional prose shown after the usage lines. */
     description?: string;
     /** Optional flat `--flag` reference list. */
     options?: readonly UsageOption[];
 }
 /** Render a {@link UsageSpec} into the "Usage:\n  ...\n\nOptions:\n  ..." text every OD help command used. */
-export declare function renderUsage(spec: UsageSpec): string;
+export declare function renderUsage({ usage }: UsageSpec, options?: UsageOptions): string;
 //# sourceMappingURL=usage.d.ts.map

package/dist/usage.js

@@ -2,21 +2,21 @@
  * @module usage
  *
  * The generic *shape* of every OD `print*Help` function, extracted from
- * `apps/daemon/src/cli.ts` (see `source-map.md`): one or more usage
+ * `apps/daemon/src/cli.ts` (see `archived provenance ledger`): one or more usage
  * invocation lines, an optional prose description, and an optional flat
  * list of `--option` descriptions. OD's actual help text is 100% product
  * content and was not ported — only the rendering convention.
  */
 /** Render a {@link UsageSpec} into the "Usage:\n  ...\n\nOptions:\n  ..." text every OD help command used. */
-export function renderUsage(spec) {
-    const lines = ['Usage:', ...spec.usage.map((line) => `  ${line}`)];
-    if (spec.description !== undefined && spec.description.length > 0) {
-        lines.push('', spec.description);
+export function renderUsage({ usage }, options = {}) {
+    const lines = ['Usage:', ...usage.map((line) => `  ${line}`)];
+    if (options.description !== undefined && options.description.length > 0) {
+        lines.push('', options.description);
     }
-    if (spec.options !== undefined && spec.options.length > 0) {
-        const longest = Math.max(...spec.options.map((option) => option.flag.length));
+    if (options.options !== undefined && options.options.length > 0) {
+        const longest = Math.max(...options.options.map((option) => option.flag.length));
         lines.push('', 'Options:');
-        for (const option of spec.options) {
+        for (const option of options.options) {
             lines.push(`  ${option.flag.padEnd(longest)}  ${option.description}`);
         }
     }

package/dist/version-command.d.ts

@@ -4,7 +4,7 @@
  * `version` — prints just the running daemon's version string. Sourced from
  * `GET /api/daemon/status`'s `version` field (`packages/http/src/daemon-status.ts`,
  * `DaemonStatusResponse.version`) — the same route `daemon-command.ts`'s `daemon status`
- * already calls. `packages/cli/source-map.md`'s original UNCLEAR verdict on a standalone
+ * already calls. `packages/cli/archived provenance ledger`'s original UNCLEAR verdict on a standalone
  * `version` command noted "@jini-ai/http-kit has no version route yet ... nothing to call"; that
  * blocker never actually required a *separate* route — `daemonStatusRoute`'s response body
  * already carries a `version` field, so no new HTTP route was added for this command. It just
@@ -21,18 +21,30 @@ export interface VersionCommandDeps {
     /** Resolves the daemon HTTP base URL once per command invocation (e.g. wraps `resolveDaemonUrl`). */
     resolveBaseUrl: () => Promise<string> | string;
     /** Defaults to `process.stdout.write`; inject for tests. Used for the printed version string. */
-    write?: (text: string) => void;
+    write?: (requiredArgs: {
+        text: string;
+    }) => void;
     /** Defaults to `process.stderr.write`; inject for tests. Used for usage/validation errors. */
-    writeErr?: (text: string) => void;
+    writeErr?: (requiredArgs: {
+        text: string;
+    }) => void;
     /** Defaults to the global `fetch`; inject for tests. */
     fetchImpl?: typeof fetch;
     /** Defaults to `process.exit`; inject for tests (must not return). */
-    exit?: (code: number) => never;
+    exit?: (requiredArgs: {
+        code: number;
+    }) => never;
     /** Extra/overriding `code -> exitCode` entries layered on the package default table. */
     exitCodes?: ExitCodeTable;
 }
 /** `version` */
-export declare function versionCommand(args: readonly string[], deps: VersionCommandDeps): Promise<void>;
+export declare function versionCommand({ args, resolveBaseUrl }: {
+    args: readonly string[];
+    resolveBaseUrl: VersionCommandDeps["resolveBaseUrl"];
+}, optionalArgs?: Omit<VersionCommandDeps, "resolveBaseUrl">): Promise<void>;
 /** Registers `version` against `registry`. */
-export declare function registerVersionCommand(registry: CommandRegistry, deps: VersionCommandDeps): void;
+export declare function registerVersionCommand({ registry, resolveBaseUrl }: {
+    registry: CommandRegistry;
+    resolveBaseUrl: VersionCommandDeps["resolveBaseUrl"];
+}, optionalArgs?: Omit<VersionCommandDeps, "resolveBaseUrl">): void;
 //# sourceMappingURL=version-command.d.ts.map

package/dist/version-command.js

@@ -4,7 +4,7 @@
  * `version` — prints just the running daemon's version string. Sourced from
  * `GET /api/daemon/status`'s `version` field (`packages/http/src/daemon-status.ts`,
  * `DaemonStatusResponse.version`) — the same route `daemon-command.ts`'s `daemon status`
- * already calls. `packages/cli/source-map.md`'s original UNCLEAR verdict on a standalone
+ * already calls. `packages/cli/archived provenance ledger`'s original UNCLEAR verdict on a standalone
  * `version` command noted "@jini-ai/http-kit has no version route yet ... nothing to call"; that
  * blocker never actually required a *separate* route — `daemonStatusRoute`'s response body
  * already carries a `version` field, so no new HTTP route was added for this command. It just
@@ -18,21 +18,18 @@
 import { exitWithStructuredError } from './errors.js';
 import { getJsonFromDaemon } from './http.js';
 import { renderUsage } from './usage.js';
-function defaultWrite(text) {
+function defaultWrite({ text }) {
     process.stdout.write(text);
 }
-function defaultWriteErr(text) {
+function defaultWriteErr({ text }) {
     process.stderr.write(text);
 }
-const VERSION_USAGE = renderUsage({
-    usage: ['version'],
-    description: 'Prints the running daemon\'s version string (nothing else — see "daemon status" for the full status envelope).',
-});
+const VERSION_USAGE = renderUsage({ usage: ['version'] }, { description: 'Prints the running daemon\'s version string (nothing else — see "daemon status" for the full status envelope).' });
 /** Builds `{write, exit, exitCodes?}` for `errors.ts`'s structured-error helpers, never assigning `exitCodes` when unset (required under `exactOptionalPropertyTypes`). */
 function errorOptions(deps) {
     return {
         write: deps.writeErr ?? defaultWriteErr,
-        exit: deps.exit ?? ((code) => process.exit(code)),
+        exit: deps.exit ?? (({ code }) => process.exit(code)),
         ...(deps.exitCodes !== undefined ? { exitCodes: deps.exitCodes } : {}),
     };
 }
@@ -61,18 +58,20 @@ function extractVersion(deps, body) {
     return exitWithStructuredError({ code: 'daemon-not-running', message: '/api/daemon/status response did not include a version string' }, errorOptions(deps));
 }
 /** `version` */
-export async function versionCommand(args, deps) {
+export async function versionCommand({ args, resolveBaseUrl }, optionalArgs = {}) {
+    const deps = { resolveBaseUrl, ...optionalArgs };
     if (args.includes('--help') || args.includes('-h')) {
-        (deps.write ?? defaultWrite)(`${VERSION_USAGE}\n`);
+        (deps.write ?? defaultWrite)({ text: `${VERSION_USAGE}\n` });
         return;
     }
     const baseUrl = await deps.resolveBaseUrl();
-    const result = await getJsonFromDaemon(baseUrl, '/api/daemon/status', transportOptions(deps));
+    const result = await getJsonFromDaemon({ base: baseUrl, route: '/api/daemon/status' }, transportOptions(deps));
     const version = extractVersion(deps, result);
-    (deps.write ?? defaultWrite)(`${version}\n`);
+    (deps.write ?? defaultWrite)({ text: `${version}\n` });
 }
 /** Registers `version` against `registry`. */
-export function registerVersionCommand(registry, deps) {
-    registry.add('version', (args) => versionCommand(args, deps), { usage: VERSION_USAGE });
+export function registerVersionCommand({ registry, resolveBaseUrl }, optionalArgs = {}) {
+    const deps = { resolveBaseUrl, ...optionalArgs };
+    registry.add({ name: 'version', handler: ({ args }) => versionCommand({ args, resolveBaseUrl: resolveBaseUrl }, optionalArgs) }, { usage: VERSION_USAGE });
 }
 //# sourceMappingURL=version-command.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/cli",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "CLI transport shell for driving a Jini daemon over HTTP: flag parsing, daemon-URL resolution, local daemon discovery, and a pluggable command registry.",
   "license": "Apache-2.0",
   "repository": {
@@ -11,6 +11,10 @@
   "jini": {
     "domain": "server",
     "kind": "cli",
+    "entries": {
+      ".": "node",
+      "./introspection": "universal"
+    },
     "runtime": "node"
   },
   "type": "module",
@@ -22,6 +26,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./introspection": {
+      "types": "./dist/introspection.d.ts",
+      "import": "./dist/introspection.js",
+      "default": "./dist/introspection.js"
     }
   },
   "bin": {
@@ -29,6 +38,9 @@
   },
   "files": [
     "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
     "!dist/**/*.test.js",
     "!dist/**/*.test.d.ts",
     "!dist/**/*.test.js.map",
@@ -40,9 +52,26 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
+  "devDependencies": {
+    "commander": "^15.0.0",
+    "@jini-ai/core": "0.4.2",
+    "@jini-ai/sidecar": "0.4.1",
+    "@jini-ai/platform": "0.5.2"
+  },
   "dependencies": {
-    "@jini-ai/core": "0.3.1",
-    "@jini-ai/sidecar": "0.3.0"
+    "@jini-ai/core": "^0.4.2"
+  },
+  "peerDependencies": {
+    "@jini-ai/platform": "^0.5.1",
+    "@jini-ai/sidecar": "^0.4.0"
+  },
+  "peerDependenciesMeta": {
+    "@jini-ai/platform": {
+      "optional": true
+    },
+    "@jini-ai/sidecar": {
+      "optional": true
+    }
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/main.js",