@jini-ai/cli 0.3.1 → 0.4.0

package/dist/local-daemon-discovery.js

@@ -2,13 +2,13 @@
  * @module local-daemon-discovery
  *
  * The real `discover` callback `resolveDaemonUrl` (`daemon-url.ts`) has always accepted but this
- * package never implemented — see `source-map.md`'s "Deferred" item 1 and its own 2026-07-21
+ * package never implemented — see `archived provenance ledger`'s "Deferred" item 1 and its own 2026-07-21
  * investigation, which found `@jini-ai/server`'s `createLocalNodeDaemon` wrote nothing anywhere a
  * separate CLI process could read. That daemon side is now built (`@jini-ai/server`'s
  * `discoveryFile` config, backed by `@jini-ai/sidecar`'s `daemon-registry.ts`); this module is the
  * matching CLI-side reader: `createLocalDaemonDiscovery(...)` builds a probe over that same
  * on-disk record, verified live (not just present — see `readLiveDaemonRegistryRecord`'s own
- * doc), that plugs directly into `resolveDaemonUrl({ discover })`.
+ * doc), that plugs directly into `resolveDaemonUrl({}, { discover })`.
  *
  * Deliberately not wired to a hardcoded default `dataDir`: exactly like `resolveDaemonUrl` itself
  * has no baked-in env var name or default URL, this package has no opinion on where a given
@@ -23,14 +23,14 @@ import { readLiveDaemonRegistryRecord, resolveDaemonRegistryPath } from '@jini-a
  * `registryPath`/`dataDir` was supplied.
  */
 function resolveRegistryPathFromOptions(options) {
-    if (options.registryPath !== undefined)
+    if ("registryPath" in options)
         return options.registryPath;
-    if (options.dataDir !== undefined)
-        return resolveDaemonRegistryPath(options.dataDir);
+    if ("dataDir" in options)
+        return resolveDaemonRegistryPath({ dataDir: options.dataDir });
     throw new Error('createLocalDaemonDiscovery requires either dataDir or registryPath');
 }
 /**
- * Build a `resolveDaemonUrl({ discover })`-compatible probe backed by a local, on-disk daemon
+ * Build a `resolveDaemonUrl({}, { discover })`-compatible probe backed by a local, on-disk daemon
  * registry record: reads the record at the resolved registry path, confirms the recording
  * process's pid is still alive (a stale record left behind by a daemon that crashed rather than
  * shut down cleanly is never trusted — see `readLiveDaemonRegistryRecord`), and returns its
@@ -46,7 +46,7 @@ function resolveRegistryPathFromOptions(options) {
 export function createLocalDaemonDiscovery(options) {
     const registryPath = resolveRegistryPathFromOptions(options);
     return async () => {
-        const record = await readLiveDaemonRegistryRecord(registryPath);
+        const record = await readLiveDaemonRegistryRecord({ registryPath });
         return record?.url ?? null;
     };
 }

package/dist/main.d.ts

@@ -1,11 +1,17 @@
 #!/usr/bin/env node
 export interface MainDeps {
     /** Defaults to `process.stdout.write`; inject for tests. */
-    write?: (text: string) => void;
+    write?: (requiredArgs: {
+        text: string;
+    }) => void;
     /** Defaults to `process.stderr.write`; inject for tests. */
-    writeErr?: (text: string) => void;
+    writeErr?: (requiredArgs: {
+        text: string;
+    }) => void;
     /** Defaults to `process.exit`; inject for tests (must not return). */
-    exit?: (code: number) => never;
+    exit?: (requiredArgs: {
+        code: number;
+    }) => never;
     /** Defaults to the global `fetch`; inject for tests. */
     fetchImpl?: typeof fetch;
     /** Defaults to `process.env`; inject for tests. */
@@ -17,5 +23,7 @@ export interface MainDeps {
  * caller under normal use — usage errors and daemon failures both exit through this package's
  * structured-error contract (`errors.ts`), via the injected (or default, real) `exit`.
  */
-export declare function main(argv: readonly string[], deps?: MainDeps): Promise<void>;
+export declare function main({ argv }: {
+    argv: readonly string[];
+}, deps?: MainDeps): Promise<void>;
 //# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -6,7 +6,7 @@
  * other module in this package is a library building block — `run-command.ts`,
  * `daemon-command.ts`, and `version-command.ts` each export a `register*Commands(registry,
  * deps)` function ready for a pack to call, but until this file, nothing actually parsed
- * `process.argv` and called them: `packages/cli/source-map.md`'s "Not built" note on
+ * `process.argv` and called them: `packages/cli/archived provenance ledger`'s "Not built" note on
  * `run-command.ts`'s original addition said as much — "no wiring of this file's commands into
  * an actual bootable CLI entrypoint." This closes that gap.
  *
@@ -22,7 +22,7 @@
  *
  * **Daemon-URL resolution.** `resolveDaemonUrl` (`daemon-url.ts`) has no baked-in default —
  * this package has never had a locked default daemon port to fall back to (see
- * `source-map.md`: `@jini-ai/server`'s `createLocalNodeDaemon` binds an ephemeral port, not a
+ * `archived provenance ledger`: `@jini-ai/server`'s `createLocalNodeDaemon` binds an ephemeral port, not a
  * fixed one). This binary wires the three real, already-built pieces together instead of
  * inventing a new one: an explicit `--daemon-url <url>` flag (highest precedence), a
  * `JINI_DAEMON_URL` env var, and — when `--data-dir <path>` or `--registry-path <path>` is
@@ -48,12 +48,12 @@
  * dispatch, so `run`/`daemon`/`version` always land as a clean first token no matter where on
  * the command line `--daemon-url`/`--data-dir`/`--registry-path` were typed.
  *
- * **`--version`/`-v`.** This package's `package.json` is `"private": true` with a placeholder
- * `"0.0.0"` version — not a real, published semver worth printing. Rather than invent one,
+ * **`--version`/`-v`.** This package has its own published semver, but this transport command reports
+ * the daemon it is controlling so operators can identify the running service. Accordingly,
  * `jini --version`/`jini -v` (recognized only as the very first token — see {@link main}) is a
  * plain alias for `jini version` (`version-command.ts`): it prints the *running daemon's* real
  * version. That is arguably more useful to a user of this transport-only CLI than this
- * package's own unpublished build number would be, and it means `--version` has exactly one
+ * package's own transport version would be, and it means `--version` has exactly one
  * implementation to keep correct, not two.
  *
  * **Error boundary.** `parseFlags` (`flags.ts`) throws a plain `Error` for an unrecognized
@@ -83,25 +83,21 @@ import { createLocalDaemonDiscovery } from './local-daemon-discovery.js';
 import { registerRunCommands } from './run-command.js';
 import { renderUsage } from './usage.js';
 import { registerVersionCommand } from './version-command.js';
-function defaultWrite(text) {
+function defaultWrite({ text }) {
     process.stdout.write(text);
 }
-function defaultWriteErr(text) {
+function defaultWriteErr({ text }) {
     process.stderr.write(text);
 }
 /** Name of the environment variable {@link resolveDaemonUrl} checks when `--daemon-url` is absent. */
 const DAEMON_URL_ENV_VAR = 'JINI_DAEMON_URL';
-const ROOT_USAGE = renderUsage({
-    usage: ['jini <command> [...args]'],
-    description: 'CLI transport for a Jini daemon over HTTP. Commands: run, daemon, version.',
-    options: [
+const ROOT_USAGE = renderUsage({ usage: ['jini <command> [...args]'] }, { description: 'CLI transport for a Jini daemon over HTTP. Commands: run, daemon, version.', options: [
         { flag: '--daemon-url <url>', description: 'Explicit daemon base URL. Takes precedence over JINI_DAEMON_URL and local discovery.' },
         { flag: '--data-dir <path>', description: "Resolve a locally running daemon's URL from this data directory's on-disk registry (see @jini-ai/server's createLocalNodeDaemon)." },
         { flag: '--registry-path <path>', description: "Exact registry file path, overriding --data-dir's derived default." },
         { flag: '--help, -h', description: 'Show this help.' },
         { flag: '--version, -v', description: 'Print the running daemon\'s version (alias for "jini version"; recognized only as the first argument).' },
-    ],
-});
+    ] });
 const GLOBAL_FLAG_NAMES = ['daemon-url', 'data-dir', 'registry-path'];
 /**
  * Single-pass extraction of this binary's own global `--daemon-url`/`--data-dir`/
@@ -154,7 +150,7 @@ function buildResolveBaseUrl(globals, env, warn) {
         : dataDir !== undefined
             ? createLocalDaemonDiscovery({ dataDir })
             : undefined;
-    return () => resolveDaemonUrl({
+    return () => resolveDaemonUrl({}, {
         flagUrl: daemonUrl ?? null,
         env,
         envVarName: DAEMON_URL_ENV_VAR,
@@ -168,13 +164,13 @@ function buildResolveBaseUrl(globals, env, warn) {
  * caller under normal use — usage errors and daemon failures both exit through this package's
  * structured-error contract (`errors.ts`), via the injected (or default, real) `exit`.
  */
-export async function main(argv, deps = {}) {
+export async function main({ argv }, deps = {}) {
     const write = deps.write ?? defaultWrite;
     const writeErr = deps.writeErr ?? defaultWriteErr;
-    const rawExit = deps.exit ?? ((code) => process.exit(code));
+    const rawExit = deps.exit ?? (({ code }) => process.exit(code));
     const env = deps.env ?? process.env;
     if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
-        write(`${ROOT_USAGE}\n`);
+        write({ text: `${ROOT_USAGE}\n` });
         return;
     }
     // `--version`/`-v` as the very first token is a plain alias for `jini version` — see this
@@ -184,26 +180,28 @@ export async function main(argv, deps = {}) {
     // already exited cleanly" (re-throw untouched) apart from "a genuinely raw, unhandled throw"
     // (reformat into a structured error) — see this file's own module doc, "Error boundary."
     let exitCalled = false;
-    const exit = (code) => {
+    const exit = ({ code }) => {
         exitCalled = true;
-        return rawExit(code);
+        return rawExit({ code });
     };
     let result;
     try {
         const { globals, rest } = partitionGlobalArgv(effectiveArgv);
-        const resolveBaseUrl = buildResolveBaseUrl(globals, env, writeErr);
-        const commandDeps = {
-            resolveBaseUrl,
-            write,
-            writeErr,
-            exit,
-            ...(deps.fetchImpl !== undefined ? { fetchImpl: deps.fetchImpl } : {}),
-        };
-        const registry = new CommandRegistry();
-        registerRunCommands(registry, commandDeps);
-        registerDaemonCommands(registry, commandDeps);
-        registerVersionCommand(registry, commandDeps);
-        result = await registry.dispatch(rest);
+        const resolveBaseUrl = buildResolveBaseUrl(globals, env, ({ message }) => writeErr({ text: message }));
+        const registry = new CommandRegistry({});
+        registerRunCommands({ registry, resolveBaseUrl }, {
+            write, writeErr, exit,
+            ...(deps.fetchImpl === undefined ? {} : { fetchImpl: deps.fetchImpl }),
+        });
+        registerDaemonCommands({ registry, resolveBaseUrl }, {
+            write, writeErr, exit,
+            ...(deps.fetchImpl === undefined ? {} : { fetchImpl: deps.fetchImpl }),
+        });
+        registerVersionCommand({ registry, resolveBaseUrl }, {
+            write, writeErr, exit,
+            ...(deps.fetchImpl === undefined ? {} : { fetchImpl: deps.fetchImpl }),
+        });
+        result = await registry.dispatch({ argv: rest });
     }
     catch (error) {
         if (exitCalled)
@@ -213,7 +211,7 @@ export async function main(argv, deps = {}) {
         return;
     }
     if (result.kind === 'empty') {
-        write(`${ROOT_USAGE}\n`);
+        write({ text: `${ROOT_USAGE}\n` });
         return;
     }
     if (result.kind === 'not-found') {
@@ -226,6 +224,6 @@ export async function main(argv, deps = {}) {
 // `require.main === module` idiom for ESM; see this file's own module doc.
 const isMainModule = process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1];
 if (isMainModule) {
-    await main(process.argv.slice(2));
+    await main({ argv: process.argv.slice(2) });
 }
 //# sourceMappingURL=main.js.map

package/dist/prompt.d.ts

@@ -7,7 +7,7 @@
  *
  * `readPromptFromFlags` is the `--prompt <text>` / `--prompt-file <path>` /
  * `--prompt-file -` convention, ported from OD's `apps/daemon/src/cli.ts`
- * `readPromptFromFlags` (see `source-map.md`). This exact pattern recurred
+ * `readPromptFromFlags` (see `archived provenance ledger`). This exact pattern recurred
  * verbatim across many of OD's product commands (`brand create`, `run
  * start`, `files version-create`, `automation source ingest`, …) with zero
  * product nouns in the reading logic itself, which is what makes it a
@@ -16,7 +16,7 @@
  *
  * `readBodyFromFlags` is the sibling `--body`/`--body-file` convention,
  * ported from the `cli-capability-barrels` branch's `cli/core/io.ts`
- * `readMemoryBodyFromFlags` (see `source-map.md`'s "Barrel branch
+ * `readMemoryBodyFromFlags` (see `archived provenance ledger`'s "Barrel branch
  * reconciliation" section). Despite the origin name, it has no memory-domain
  * coupling — that module's own docblock confirms it is reused verbatim by
  * both the memory and automation domains — so it is ported here under a
@@ -34,7 +34,9 @@
  */
 /** Thrown by the default readers when a file or stdin stream exceeds its configured byte cap. */
 export declare class PayloadTooLargeError extends Error {
-    constructor(message: string);
+    constructor({ message }: {
+        message: string;
+    });
 }
 export interface PromptFlags {
     prompt?: string;
@@ -42,7 +44,9 @@ export interface PromptFlags {
 }
 export interface ReadPromptFromFlagsOptions {
     /** Defaults to a bounded, cancellable `node:fs` stream read; inject for tests. */
-    readFile?: (path: string) => Promise<string>;
+    readFile?: (requiredArgs: {
+        path: string;
+    }) => Promise<string>;
     /** Defaults to a bounded, cancellable read of `process.stdin` to EOF as utf8; inject for tests. */
     readStdin?: () => Promise<string>;
     /** Maximum bytes the default readFile/readStdin will read before rejecting. Defaults to 10 MiB. No effect on an injected reader. */
@@ -55,14 +59,18 @@ export interface ReadPromptFromFlagsOptions {
  * `--prompt-file -` (stdin). Returns `null` when neither flag is set so the
  * caller can fall back to its own default.
  */
-export declare function readPromptFromFlags(flags: PromptFlags, options?: ReadPromptFromFlagsOptions): Promise<string | null>;
+export declare function readPromptFromFlags({ flags }: {
+    flags: PromptFlags;
+}, options?: ReadPromptFromFlagsOptions): Promise<string | null>;
 export interface BodyFlags {
     body?: string;
     'body-file'?: string;
 }
 export interface ReadBodyFromFlagsOptions {
     /** Defaults to a bounded, cancellable `node:fs` stream read; inject for tests. */
-    readFile?: (path: string) => Promise<string>;
+    readFile?: (requiredArgs: {
+        path: string;
+    }) => Promise<string>;
     /** Defaults to a bounded, cancellable drain of `process.stdin`'s async iterator as utf8; inject for tests. */
     readStdin?: () => Promise<string>;
     /** Maximum bytes the default readFile/readStdin will read before rejecting. Defaults to 10 MiB. No effect on an injected reader. */
@@ -79,5 +87,7 @@ export interface ReadBodyFromFlagsOptions {
  * primitive's origin caller (`od memory tree edit`) needs to allow clearing
  * a body to an empty string.
  */
-export declare function readBodyFromFlags(flags: BodyFlags, options?: ReadBodyFromFlagsOptions): Promise<string | undefined>;
+export declare function readBodyFromFlags({ flags }: {
+    flags: BodyFlags;
+}, options?: ReadBodyFromFlagsOptions): Promise<string | undefined>;
 //# sourceMappingURL=prompt.d.ts.map

package/dist/prompt.js

@@ -7,7 +7,7 @@
  *
  * `readPromptFromFlags` is the `--prompt <text>` / `--prompt-file <path>` /
  * `--prompt-file -` convention, ported from OD's `apps/daemon/src/cli.ts`
- * `readPromptFromFlags` (see `source-map.md`). This exact pattern recurred
+ * `readPromptFromFlags` (see `archived provenance ledger`). This exact pattern recurred
  * verbatim across many of OD's product commands (`brand create`, `run
  * start`, `files version-create`, `automation source ingest`, …) with zero
  * product nouns in the reading logic itself, which is what makes it a
@@ -16,7 +16,7 @@
  *
  * `readBodyFromFlags` is the sibling `--body`/`--body-file` convention,
  * ported from the `cli-capability-barrels` branch's `cli/core/io.ts`
- * `readMemoryBodyFromFlags` (see `source-map.md`'s "Barrel branch
+ * `readMemoryBodyFromFlags` (see `archived provenance ledger`'s "Barrel branch
  * reconciliation" section). Despite the origin name, it has no memory-domain
  * coupling — that module's own docblock confirms it is reused verbatim by
  * both the memory and automation domains — so it is ported here under a
@@ -34,7 +34,7 @@
  */
 /** Thrown by the default readers when a file or stdin stream exceeds its configured byte cap. */
 export class PayloadTooLargeError extends Error {
-    constructor(message) {
+    constructor({ message }) {
         super(message);
         this.name = 'PayloadTooLargeError';
     }
@@ -46,7 +46,7 @@ const DEFAULT_MAX_READ_BYTES = 10 * 1024 * 1024;
  * `--prompt-file -` (stdin). Returns `null` when neither flag is set so the
  * caller can fall back to its own default.
  */
-export async function readPromptFromFlags(flags, options = {}) {
+export async function readPromptFromFlags({ flags }, options = {}) {
     if (typeof flags.prompt === 'string' && flags.prompt.length > 0) {
         return flags.prompt;
     }
@@ -59,8 +59,8 @@ export async function readPromptFromFlags(flags, options = {}) {
         const readStdin = options.readStdin ?? (() => defaultReadStdin(readLimits));
         return await readStdin();
     }
-    const readFile = options.readFile ?? ((path) => defaultReadFile(path, readLimits));
-    return await readFile(promptFile);
+    const readFile = options.readFile ?? (({ path }) => defaultReadFile(path, readLimits));
+    return await readFile({ path: promptFile });
 }
 async function defaultReadFile(path, limits) {
     const { createReadStream } = await import('node:fs');
@@ -76,7 +76,7 @@ async function defaultReadFile(path, limits) {
         // suppress any further 'error' from the destroy path itself). Kept as
         // real protection against a future/third-party stream implementation
         // bug, not something this module's own real `createReadStream` usage
-        // can trigger — see `source-map.md`'s dated entry for the full
+        // can trigger — see `archived provenance ledger`'s dated entry for the full
         // re-verification record (a single terminal event is all this file's
         // own usage can ever produce).
         const finish = (fn) => {
@@ -98,7 +98,7 @@ async function defaultReadFile(path, limits) {
             total += chunk.length;
             if (total > limits.maxBytes) {
                 stream.destroy();
-                finish(() => reject(new PayloadTooLargeError(`file exceeded the ${limits.maxBytes}-byte limit: ${path}`)));
+                finish(() => reject(new PayloadTooLargeError({ message: `file exceeded the ${limits.maxBytes}-byte limit: ${path}` })));
                 return;
             }
             chunks.push(chunk);
@@ -130,7 +130,7 @@ async function defaultReadStdin(limits) {
             if (total > limits.maxBytes) {
                 cleanup();
                 pauseStdin();
-                reject(new PayloadTooLargeError(`stdin exceeded the ${limits.maxBytes}-byte limit`));
+                reject(new PayloadTooLargeError({ message: `stdin exceeded the ${limits.maxBytes}-byte limit` }));
                 return;
             }
             buffer += chunk;
@@ -157,7 +157,7 @@ async function defaultReadStdin(limits) {
  * primitive's origin caller (`od memory tree edit`) needs to allow clearing
  * a body to an empty string.
  */
-export async function readBodyFromFlags(flags, options = {}) {
+export async function readBodyFromFlags({ flags }, options = {}) {
     if (typeof flags.body === 'string')
         return flags.body;
     const bodyFile = flags['body-file'];
@@ -168,8 +168,8 @@ export async function readBodyFromFlags(flags, options = {}) {
         const readStdin = options.readStdin ?? (() => defaultReadBodyStdin(readLimits));
         return await readStdin();
     }
-    const readFile = options.readFile ?? ((path) => defaultReadFile(path, readLimits));
-    return await readFile(bodyFile);
+    const readFile = options.readFile ?? (({ path }) => defaultReadFile(path, readLimits));
+    return await readFile({ path: bodyFile });
 }
 async function defaultReadBodyStdin(limits) {
     limits.signal?.throwIfAborted();
@@ -185,7 +185,7 @@ async function defaultReadBodyStdin(limits) {
             total += Buffer.byteLength(text, 'utf8');
             if (total > limits.maxBytes) {
                 stdin.destroy?.();
-                throw new PayloadTooLargeError(`stdin exceeded the ${limits.maxBytes}-byte limit`);
+                throw new PayloadTooLargeError({ message: `stdin exceeded the ${limits.maxBytes}-byte limit` });
             }
             body += text;
         }

package/dist/redact.d.ts

@@ -17,25 +17,6 @@
  * arbitrary daemon JSON, or complete non-JSON response bodies straight to
  * the terminal.
  */
-/**
- * Strip ANSI/terminal escape sequences (CSI `ESC [ ... final-byte`, OSC `ESC ] ... BEL-or-ST`,
- * and bare ESC-prefixed bytes) plus other C0/C1 control characters from `text`. Written as an
- * explicit char-code scanner rather than a regex literal with hex escapes, so the pattern is
- * plain ASCII source with no embedded control bytes.
- */
-export declare function stripControlSequences(text: string): string;
-/** Redact labeled credentials and long opaque-token-looking substrings from `text`. */
-export declare function redactSecretLike(text: string): string;
-export interface SanitizeTextOptions {
-    /** Maximum output length; longer input is truncated with a trailing marker. Defaults to 500. */
-    maxLength?: number;
-}
-/**
- * Strip terminal control sequences, redact anything that looks like a secret, and cap the
- * length of `text` — the one function every boundary that surfaces daemon/network-derived text
- * to stderr/stdout should route through first.
- */
-export declare function sanitizeUntrustedText(text: string, options?: SanitizeTextOptions): string;
 /**
  * Recursively sanitize an arbitrary parsed-JSON value (the shape a daemon error envelope's
  * `data`/`details` field can legitimately be): every string leaf is passed through
@@ -44,5 +25,9 @@ export declare function sanitizeUntrustedText(text: string, options?: SanitizeTe
  * the cap is replaced with a placeholder rather than silently dropped, so truncation is visible
  * instead of looking like an empty/missing value.
  */
-export declare function sanitizeUnknownDeep(value: unknown, depth?: number): unknown;
+export declare function sanitizeUnknownDeep({ value }: {
+    value: unknown;
+}, { depth }?: {
+    depth?: number;
+}): unknown;
 //# sourceMappingURL=redact.d.ts.map

package/dist/redact.js

@@ -17,102 +17,10 @@
  * arbitrary daemon JSON, or complete non-JSON response bodies straight to
  * the terminal.
  */
-/** Hard cap on how much untrusted text {@link sanitizeUntrustedText} will ever return, absent an override. */
-const DEFAULT_MAX_EXCERPT_LENGTH = 500;
+import { sanitizeUntrustedText } from '@jini-ai/core/text';
 /** Recursion/branching caps for {@link sanitizeUnknownDeep} — bounds the work done on an arbitrary parsed-JSON tree. */
 const MAX_SANITIZE_DEPTH = 4;
 const MAX_SANITIZE_ENTRIES = 50;
-const ESC = 0x1b;
-const BEL = 0x07;
-const BACKSLASH = 0x5c;
-const OSC_OPEN = 0x5d; // ']'
-const CSI_OPEN = 0x5b; // '['
-function isCsiFinalByte(code) {
-    return code >= 0x40 && code <= 0x7e; // '@'..'~'
-}
-function isOtherControlCode(code) {
-    if (code === 0x09 || code === 0x0a || code === 0x0d)
-        return false; // tab / LF / CR pass through
-    if (code <= 0x1f)
-        return true; // remaining C0 controls (ESC itself is handled separately)
-    if (code === 0x7f)
-        return true; // DEL
-    if (code >= 0x80 && code <= 0x9f)
-        return true; // C1 controls
-    return false;
-}
-/**
- * Strip ANSI/terminal escape sequences (CSI `ESC [ ... final-byte`, OSC `ESC ] ... BEL-or-ST`,
- * and bare ESC-prefixed bytes) plus other C0/C1 control characters from `text`. Written as an
- * explicit char-code scanner rather than a regex literal with hex escapes, so the pattern is
- * plain ASCII source with no embedded control bytes.
- */
-export function stripControlSequences(text) {
-    let out = '';
-    for (let i = 0; i < text.length; i++) {
-        const code = text.charCodeAt(i);
-        if (code === ESC) {
-            const next = text.charCodeAt(i + 1);
-            if (next === CSI_OPEN) {
-                let j = i + 2;
-                while (j < text.length && !isCsiFinalByte(text.charCodeAt(j)))
-                    j++;
-                i = j; // land on the final byte; the outer loop's i++ steps past it
-                continue;
-            }
-            if (next === OSC_OPEN) {
-                let j = i + 2;
-                while (j < text.length &&
-                    text.charCodeAt(j) !== BEL &&
-                    !(text.charCodeAt(j) === ESC && text.charCodeAt(j + 1) === BACKSLASH)) {
-                    j++;
-                }
-                if (j < text.length && text.charCodeAt(j) === BEL)
-                    i = j;
-                else
-                    i = Math.min(j + 1, text.length - 1);
-                continue;
-            }
-            continue; // bare ESC (or an unrecognized ESC-prefixed byte): drop just the ESC byte
-        }
-        if (isOtherControlCode(code))
-            continue;
-        out += text[i];
-    }
-    return out;
-}
-// A labeled credential (`Authorization: ...`, `api-key=...`) has everything after the label
-// redacted. A bare run of 20+ base64url/hex-alphabet characters is treated as a possible
-// opaque token/secret and redacted outright, even with no label.
-const LABELED_SECRET_RE = /\b(authorization|bearer|api[-_]?key|access[-_]?token|refresh[-_]?token|client[-_]?secret|password|secret|cookie)\b\s*[:=]\s*\S+/gi;
-const OPAQUE_TOKEN_RE = /[A-Za-z0-9_-]{20,}/g;
-/**
- * Whole opaque-token runs that are known not to be secrets, kept verbatim. Matched against the
- * ENTIRE run, so a secret glued onto one of these is still one longer run and still redacted:
- * - a host's tool-failure correlation id (`ERR-XXXX-XXXX-XXXX-XXXX`, upper-case hex — Tovu's
- *   `mintToolErrorId`), which exists to be shown to the model and quoted back to an operator;
- * - `delegated-tool-calls`, the daemon route segment every delegated tool failure names in its URL.
- */
-const NON_SECRET_TOKEN_RE = /^(?:ERR-[0-9A-F]{4}(?:-[0-9A-F]{4}){3}|delegated-tool-calls)$/;
-/** Redact labeled credentials and long opaque-token-looking substrings from `text`. */
-export function redactSecretLike(text) {
-    return text
-        .replace(LABELED_SECRET_RE, (match) => match.replace(/\S+$/, '[redacted]'))
-        .replace(OPAQUE_TOKEN_RE, (match) => (NON_SECRET_TOKEN_RE.test(match) ? match : '[redacted]'));
-}
-/**
- * Strip terminal control sequences, redact anything that looks like a secret, and cap the
- * length of `text` — the one function every boundary that surfaces daemon/network-derived text
- * to stderr/stdout should route through first.
- */
-export function sanitizeUntrustedText(text, options = {}) {
-    const maxLength = options.maxLength ?? DEFAULT_MAX_EXCERPT_LENGTH;
-    const sanitized = redactSecretLike(stripControlSequences(text));
-    if (sanitized.length <= maxLength)
-        return sanitized;
-    const omitted = sanitized.length - maxLength;
-    return `${sanitized.slice(0, maxLength)}… [truncated ${omitted} more characters]`;
-}
 /**
  * Recursively sanitize an arbitrary parsed-JSON value (the shape a daemon error envelope's
  * `data`/`details` field can legitimately be): every string leaf is passed through
@@ -121,18 +29,18 @@ export function sanitizeUntrustedText(text, options = {}) {
  * the cap is replaced with a placeholder rather than silently dropped, so truncation is visible
  * instead of looking like an empty/missing value.
  */
-export function sanitizeUnknownDeep(value, depth = 0) {
+export function sanitizeUnknownDeep({ value }, { depth = 0 } = {}) {
     if (depth > MAX_SANITIZE_DEPTH)
         return '[omitted: nested too deeply]';
     if (typeof value === 'string')
-        return sanitizeUntrustedText(value);
+        return sanitizeUntrustedText({ text: value });
     if (Array.isArray(value)) {
-        return value.slice(0, MAX_SANITIZE_ENTRIES).map((item) => sanitizeUnknownDeep(item, depth + 1));
+        return value.slice(0, MAX_SANITIZE_ENTRIES).map((item) => sanitizeUnknownDeep({ value: item }, { depth: depth + 1 }));
     }
     if (value !== null && typeof value === 'object') {
         const out = {};
         for (const [key, val] of Object.entries(value).slice(0, MAX_SANITIZE_ENTRIES)) {
-            out[sanitizeUntrustedText(key, { maxLength: 100 })] = sanitizeUnknownDeep(val, depth + 1);
+            out[sanitizeUntrustedText({ text: key }, { maxLength: 100 })] = sanitizeUnknownDeep({ value: val }, { depth: depth + 1 });
         }
         return out;
     }

package/dist/run-command.d.ts

@@ -4,24 +4,42 @@ export interface RunCommandDeps {
     /** 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 successful command output. */
-    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;
 }
 /** `run start --context-ref <ref> [--agent-id <id>] [--idempotency-key <key>]` */
-export declare function runStartCommand(args: readonly string[], deps: RunCommandDeps): Promise<void>;
+export declare function runStartCommand({ args, resolveBaseUrl: resolveBaseUrlPort }: {
+    args: readonly string[];
+    resolveBaseUrl: RunCommandDeps["resolveBaseUrl"];
+}, optionalArgs?: Omit<RunCommandDeps, "resolveBaseUrl">): Promise<void>;
 /** `run list [--context-ref <ref>]` */
-export declare function runListCommand(args: readonly string[], deps: RunCommandDeps): Promise<void>;
+export declare function runListCommand({ args, resolveBaseUrl: resolveBaseUrlPort }: {
+    args: readonly string[];
+    resolveBaseUrl: RunCommandDeps["resolveBaseUrl"];
+}, optionalArgs?: Omit<RunCommandDeps, "resolveBaseUrl">): Promise<void>;
 /** `run get <runId>` */
-export declare function runGetCommand(args: readonly string[], deps: RunCommandDeps): Promise<void>;
+export declare function runGetCommand({ args, resolveBaseUrl: resolveBaseUrlPort }: {
+    args: readonly string[];
+    resolveBaseUrl: RunCommandDeps["resolveBaseUrl"];
+}, optionalArgs?: Omit<RunCommandDeps, "resolveBaseUrl">): Promise<void>;
 /** `run cancel <runId> [--reason <text>]` */
-export declare function runCancelCommand(args: readonly string[], deps: RunCommandDeps): Promise<void>;
+export declare function runCancelCommand({ args, resolveBaseUrl: resolveBaseUrlPort }: {
+    args: readonly string[];
+    resolveBaseUrl: RunCommandDeps["resolveBaseUrl"];
+}, optionalArgs?: Omit<RunCommandDeps, "resolveBaseUrl">): Promise<void>;
 /**
  * Streams `GET /api/runs/:runId/events` and writes one NDJSON line per event to `deps.write`,
  * stopping once a terminal `'end'` event arrives (or the stream closes on its own). Each frame's
@@ -31,9 +49,19 @@ export declare function runCancelCommand(args: readonly string[], deps: RunComma
  * the way a diagnostic error message is, since it is the run's actual event payload, not incidental
  * error detail.
  */
-export declare function watchRunEvents(baseUrl: string, runId: string, args: readonly string[], deps: RunCommandDeps): Promise<void>;
+export declare function watchRunEvents({ baseUrl, runId, args }: {
+    baseUrl: string;
+    runId: string;
+    args: readonly string[];
+}, deps?: Omit<RunCommandDeps, "resolveBaseUrl">): Promise<void>;
 /** `run watch <runId> [--after-cursor <cursor>]` */
-export declare function runWatchCommand(args: readonly string[], deps: RunCommandDeps): Promise<void>;
+export declare function runWatchCommand({ args, resolveBaseUrl: resolveBaseUrlPort }: {
+    args: readonly string[];
+    resolveBaseUrl: RunCommandDeps["resolveBaseUrl"];
+}, optionalArgs?: Omit<RunCommandDeps, "resolveBaseUrl">): Promise<void>;
 /** Registers `run` (dispatching `start`/`list`/`cancel`/`watch` on the first remaining token) against `registry`. */
-export declare function registerRunCommands(registry: CommandRegistry, deps: RunCommandDeps): void;
+export declare function registerRunCommands({ registry, resolveBaseUrl: resolveBaseUrlPort }: {
+    registry: CommandRegistry;
+    resolveBaseUrl: RunCommandDeps["resolveBaseUrl"];
+}, optionalArgs?: Omit<RunCommandDeps, "resolveBaseUrl">): void;
 //# sourceMappingURL=run-command.d.ts.map