@jini-ai/cli 0.1.0

package/dist/daemon-url.js

@@ -0,0 +1,99 @@
+/**
+ * @module daemon-url
+ *
+ * Generic daemon-URL resolution, generalized from OD's
+ * `apps/daemon/src/daemon-url.ts` (see `source-map.md`). The *order* —
+ * explicit flag, then an env var, then an injected discovery probe, then a
+ * caller-supplied default — is the reusable part. OD's own implementation
+ * hardcodes its sidecar IPC protocol and a `pnpm exec tools-dev status`
+ * fallback; neither belongs in a product-neutral package, so both are
+ * replaced with an injected `discover` callback the caller (e.g. a future
+ * `@jini-ai/sidecar`-backed adapter) supplies.
+ */
+/**
+ * Resolve a daemon HTTP base URL for a CLI client command.
+ *
+ * Resolution order: `flagUrl`, then `env[envVarName]` (when `envVarName` is
+ * given), then `discover()` (when given), then `defaultUrl`. Throws when
+ * every step is exhausted and no `defaultUrl` was supplied — a silent
+ * `http://127.0.0.1:0`-style fallback would be worse than a clear error,
+ * and this package has no locked default port to fall back to on its own.
+ */
+export async function resolveDaemonUrl(options = {}) {
+    const env = options.env ?? process.env;
+    const warn = options.warn ?? (() => { });
+    const report = (url) => {
+        const warning = daemonUrlPolicyWarning(url);
+        if (warning !== null)
+            warn(warning);
+        return url;
+    };
+    const flagUrl = options.flagUrl ?? null;
+    if (flagUrl !== null && flagUrl.length > 0)
+        return report(flagUrl);
+    if (options.envVarName !== undefined) {
+        const envUrl = env[options.envVarName];
+        if (envUrl !== undefined && envUrl.length > 0)
+            return report(envUrl);
+    }
+    if (options.discover !== undefined) {
+        const discovered = await options.discover(env, options.timeoutMs ?? 800);
+        if (discovered !== null && discovered.length > 0)
+            return report(discovered);
+    }
+    if (options.defaultUrl !== undefined)
+        return report(options.defaultUrl);
+    throw new Error('no daemon URL resolved: pass flagUrl, set envVarName on a populated env var, ' +
+        'supply a discover() probe, or provide defaultUrl.');
+}
+// Matches a scheme + userinfo prefix (`scheme://user:pass@`) on a URL string that failed to
+// parse via the `URL` constructor, so userinfo can still be stripped from a malformed value
+// before it's ever printed.
+const USERINFO_PREFIX_RE = /^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)[^/@]*@/;
+/**
+ * Return `url` with any embedded userinfo (`user:pass@host`) stripped, safe to include in a
+ * printed error message, log line, or structured-error envelope. Per SEC-RB-009
+ * (`ADS-memory/reports/security/SEC-remaining-backend-audit-2026-07-21.md`), a daemon URL a
+ * caller configures themselves can legitimately carry basic-auth credentials; those must never
+ * reach stderr/stdout verbatim. Returns `url` unchanged when it has no userinfo, so normal URLs
+ * are never reformatted/normalized as a side effect of display-sanitizing them.
+ */
+export function sanitizeDaemonUrlForDisplay(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return url.replace(USERINFO_PREFIX_RE, '$1');
+    }
+    if (parsed.username.length === 0 && parsed.password.length === 0)
+        return url;
+    parsed.username = '';
+    parsed.password = '';
+    return parsed.toString();
+}
+const LOOPBACK_HOSTNAMES = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
+function isLoopbackHostname(hostname) {
+    return LOOPBACK_HOSTNAMES.has(hostname.toLowerCase());
+}
+/**
+ * Non-fatal policy check for a resolved daemon URL: warn (never throw or reject) when it is
+ * neither loopback nor HTTPS, since that combination sends CLI traffic — including whatever
+ * headers/body a command sends — over an unencrypted connection to a non-local host. Returns
+ * `null` when the URL looks safe or doesn't parse (a parse failure is reported elsewhere, by
+ * whatever code actually tries to use the URL).
+ */
+export function daemonUrlPolicyWarning(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.protocol === 'https:' || isLoopbackHostname(parsed.hostname))
+        return null;
+    return (`daemon URL ${sanitizeDaemonUrlForDisplay(url)} is neither loopback nor HTTPS; ` +
+        'traffic to a remote, non-HTTPS daemon is not encrypted.');
+}
+//# sourceMappingURL=daemon-url.js.map

package/dist/daemon-url.js.map

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

package/dist/errors.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @module errors
+ *
+ * Structured error / exit-code handling, generalized from OD's
+ * `apps/daemon/src/cli.ts` `exitWithStructuredError`/`structuredHttpFailure`
+ * (see `source-map.md`). The mechanism — map a stable error `code` to a
+ * process exit code, write a `{ error: { code, message, data } }` envelope
+ * to stderr — is generic CLI transport plumbing; OD's own exit-code table
+ * (`plugin-not-found`, `snapshot-stale`, …) is product-specific and was not
+ * ported. Callers extend {@link DEFAULT_CLI_EXIT_CODES} with their own pack's
+ * codes rather than this package hosting one global mutable map.
+ */
+export type ExitCodeTable = Readonly<Record<string, number>>;
+/** A minimal, product-neutral starting table. Packs extend this with their own codes. */
+export declare const DEFAULT_CLI_EXIT_CODES: ExitCodeTable;
+export interface StructuredErrorEnvelope {
+    error: {
+        code: string;
+        message: string;
+        data: Record<string, unknown>;
+    };
+}
+export interface ExitWithStructuredErrorInput {
+    code: string;
+    message: string;
+    data?: Record<string, unknown>;
+}
+export interface StructuredErrorOptions {
+    /** Extra/overriding `code -> exitCode` entries layered on {@link DEFAULT_CLI_EXIT_CODES}. */
+    exitCodes?: ExitCodeTable;
+    /** Defaults to `process.stderr.write`; inject for tests. */
+    write?: (text: string) => void;
+    /** Defaults to `process.exit`; inject for tests (must not return). */
+    exit?: (code: number) => never;
+}
+/**
+ * Write a `{ error }` envelope to stderr and exit with the code mapped from
+ * `input.code` (falling back to `1` for an unrecognized code).
+ */
+export declare function exitWithStructuredError(input: ExitWithStructuredErrorInput, options?: StructuredErrorOptions): never;
+interface DaemonErrorBody {
+    code?: unknown;
+    message?: unknown;
+    data?: unknown;
+    details?: unknown;
+    retryable?: unknown;
+}
+/** The minimal shape of a `fetch()` `Response` this module needs. */
+export interface HttpFailureLike {
+    status: number;
+    text(): Promise<string>;
+}
+/**
+ * Extract `{ data }` worth surfacing to the structured envelope from a
+ * daemon error body: any `data` fields, plus `details`/`retryable` when
+ * present. Returns `undefined` when there's nothing to attach.
+ *
+ * `data`/`details` are daemon-supplied and untrusted, so both are run
+ * through {@link sanitizeUnknownDeep} — every string leaf gets bounded,
+ * control-sequence-stripped, and secret-redacted before it can reach a
+ * printed envelope (CR-004/SEC-RB-009).
+ */
+export declare function structuredErrorData(error: DaemonErrorBody | undefined): Record<string, unknown> | undefined;
+/**
+ * Map a daemon HTTP error response into the structured exit-code envelope.
+ * Daemon error bodies come in two shapes in practice: `{ error: { code,
+ * message, ... } }` (structured routes) and `{ error: '<message>' }` (flat
+ * legacy routes) — both normalize so the message always reaches the
+ * envelope instead of collapsing to a bare `HTTP <status>`.
+ *
+ * Per CR-004/SEC-RB-009, when there is no structured `message` this no
+ * longer embeds the complete raw response body verbatim into `message`
+ * (a malicious/broken daemon's body could be enormous, contain terminal
+ * control sequences, or echo back a secret). The envelope's `message` stays
+ * a stable `HTTP <status>` in that case; a bounded, redacted excerpt of the
+ * raw body is attached separately as `data.rawExcerpt` instead. A
+ * structured `message` (when present) is still sanitized — it originates
+ * from the same untrusted response.
+ */
+export declare function structuredHttpFailure(resp: HttpFailureLike, fallbackCode?: string, options?: StructuredErrorOptions): Promise<never>;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAYH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAE7D,yFAAyF;AACzF,eAAO,MAAM,sBAAsB,EAAE,aAIpC,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC/B,CAAC;CACH;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,sBAAsB;IACrC,6FAA6F;IAC7F,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,4DAA4D;IAC5D,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,sEAAsE;IACtE,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,4BAA4B,EACnC,OAAO,GAAE,sBAA2B,GACnC,KAAK,CAUP;AAED,UAAU,eAAe;IACvB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAS3G;AAUD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,eAAe,EACrB,YAAY,SAAuB,EACnC,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,KAAK,CAAC,CAiBhB"}

package/dist/errors.js

@@ -0,0 +1,103 @@
+/**
+ * @module errors
+ *
+ * Structured error / exit-code handling, generalized from OD's
+ * `apps/daemon/src/cli.ts` `exitWithStructuredError`/`structuredHttpFailure`
+ * (see `source-map.md`). The mechanism — map a stable error `code` to a
+ * process exit code, write a `{ error: { code, message, data } }` envelope
+ * to stderr — is generic CLI transport plumbing; OD's own exit-code table
+ * (`plugin-not-found`, `snapshot-stale`, …) is product-specific and was not
+ * ported. Callers extend {@link DEFAULT_CLI_EXIT_CODES} with their own pack's
+ * codes rather than this package hosting one global mutable map.
+ */
+import { sanitizeUnknownDeep, sanitizeUntrustedText, stripControlSequences } from './redact.js';
+/** A minimal, product-neutral starting table. Packs extend this with their own codes. */
+export const DEFAULT_CLI_EXIT_CODES = {
+    'daemon-not-running': 64,
+    'missing-input': 67,
+    'invalid-flag': 2,
+};
+/**
+ * Write a `{ error }` envelope to stderr and exit with the code mapped from
+ * `input.code` (falling back to `1` for an unrecognized code).
+ */
+export function exitWithStructuredError(input, options = {}) {
+    const exitCodes = { ...DEFAULT_CLI_EXIT_CODES, ...options.exitCodes };
+    const exitCode = exitCodes[input.code] ?? 1;
+    const envelope = {
+        error: { code: input.code, message: input.message, data: input.data ?? {} },
+    };
+    const write = options.write ?? ((text) => { process.stderr.write(text); });
+    const exit = options.exit ?? ((code) => process.exit(code));
+    write(`${JSON.stringify(envelope)}\n`);
+    return exit(exitCode);
+}
+/**
+ * Extract `{ data }` worth surfacing to the structured envelope from a
+ * daemon error body: any `data` fields, plus `details`/`retryable` when
+ * present. Returns `undefined` when there's nothing to attach.
+ *
+ * `data`/`details` are daemon-supplied and untrusted, so both are run
+ * through {@link sanitizeUnknownDeep} — every string leaf gets bounded,
+ * control-sequence-stripped, and secret-redacted before it can reach a
+ * printed envelope (CR-004/SEC-RB-009).
+ */
+export function structuredErrorData(error) {
+    if (error === undefined)
+        return undefined;
+    const data = {};
+    if (error.data !== undefined && typeof error.data === 'object' && error.data !== null) {
+        Object.assign(data, sanitizeUnknownDeep(error.data));
+    }
+    if (error.details !== undefined)
+        data.details = sanitizeUnknownDeep(error.details);
+    if (typeof error.retryable === 'boolean')
+        data.retryable = error.retryable;
+    return Object.keys(data).length > 0 ? data : undefined;
+}
+function extractErrorObject(parsed) {
+    if (typeof parsed !== 'object' || parsed === null || !('error' in parsed))
+        return undefined;
+    const error = parsed.error;
+    if (typeof error === 'string')
+        return { message: error };
+    if (typeof error === 'object' && error !== null)
+        return error;
+    return undefined;
+}
+/**
+ * Map a daemon HTTP error response into the structured exit-code envelope.
+ * Daemon error bodies come in two shapes in practice: `{ error: { code,
+ * message, ... } }` (structured routes) and `{ error: '<message>' }` (flat
+ * legacy routes) — both normalize so the message always reaches the
+ * envelope instead of collapsing to a bare `HTTP <status>`.
+ *
+ * Per CR-004/SEC-RB-009, when there is no structured `message` this no
+ * longer embeds the complete raw response body verbatim into `message`
+ * (a malicious/broken daemon's body could be enormous, contain terminal
+ * control sequences, or echo back a secret). The envelope's `message` stays
+ * a stable `HTTP <status>` in that case; a bounded, redacted excerpt of the
+ * raw body is attached separately as `data.rawExcerpt` instead. A
+ * structured `message` (when present) is still sanitized — it originates
+ * from the same untrusted response.
+ */
+export async function structuredHttpFailure(resp, fallbackCode = 'daemon-not-running', options = {}) {
+    let raw = '';
+    let parsed = {};
+    try {
+        raw = await resp.text();
+        parsed = raw.length > 0 ? JSON.parse(raw) : {};
+    }
+    catch {
+        parsed = {};
+    }
+    const errorObj = extractErrorObject(parsed);
+    const data = structuredErrorData(errorObj);
+    const code = typeof errorObj?.code === 'string' ? stripControlSequences(errorObj.code) : fallbackCode;
+    const structuredMessage = typeof errorObj?.message === 'string' ? sanitizeUntrustedText(errorObj.message) : undefined;
+    const message = structuredMessage ?? `HTTP ${resp.status}`;
+    const rawExcerpt = structuredMessage === undefined && raw.length > 0 ? sanitizeUntrustedText(raw) : undefined;
+    const mergedData = rawExcerpt !== undefined ? { ...(data ?? {}), rawExcerpt } : data;
+    return exitWithStructuredError({ code, message, ...(mergedData !== undefined ? { data: mergedData } : {}) }, options);
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAYhG,yFAAyF;AACzF,MAAM,CAAC,MAAM,sBAAsB,GAAkB;IACnD,oBAAoB,EAAE,EAAE;IACxB,eAAe,EAAE,EAAE;IACnB,cAAc,EAAE,CAAC;CAClB,CAAC;AAyBF;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAmC,EACnC,UAAkC,EAAE;IAEpC,MAAM,SAAS,GAAkB,EAAE,GAAG,sBAAsB,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IACrF,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,QAAQ,GAA4B;QACxC,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE,EAAE;KAC5E,CAAC;IACF,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,IAAY,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACnF,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACpE,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACvC,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC;AACxB,CAAC;AAgBD;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAkC;IACpE,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC1C,MAAM,IAAI,GAA4B,EAAE,CAAC;IACzC,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACtF,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAA4B,CAAC,CAAC;IAClF,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;QAAE,IAAI,CAAC,OAAO,GAAG,mBAAmB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACnF,IAAI,OAAO,KAAK,CAAC,SAAS,KAAK,SAAS;QAAE,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IAC3E,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AACzD,CAAC;AAED,SAAS,kBAAkB,CAAC,MAAe;IACzC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,IAAI,CAAC,CAAC,OAAO,IAAI,MAAM,CAAC;QAAE,OAAO,SAAS,CAAC;IAC5F,MAAM,KAAK,GAAI,MAA8B,CAAC,KAAK,CAAC;IACpD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IACzD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAwB,CAAC;IACjF,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,IAAqB,EACrB,YAAY,GAAG,oBAAoB,EACnC,UAAkC,EAAE;IAEpC,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,IAAI,MAAM,GAAY,EAAE,CAAC;IACzB,IAAI,CAAC;QACH,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QACxB,MAAM,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACjD,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,GAAG,EAAE,CAAC;IACd,CAAC;IACD,MAAM,QAAQ,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,OAAO,QAAQ,EAAE,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,qBAAqB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC;IACtG,MAAM,iBAAiB,GAAG,OAAO,QAAQ,EAAE,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,qBAAqB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACtH,MAAM,OAAO,GAAG,iBAAiB,IAAI,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;IAC3D,MAAM,UAAU,GAAG,iBAAiB,KAAK,SAAS,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9G,MAAM,UAAU,GAAG,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACrF,OAAO,uBAAuB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;AACxH,CAAC"}

package/dist/flags.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module flags
+ *
+ * Generic `argv` → flags parsing, ported from OD's `apps/daemon/src/cli.ts`
+ * `parseFlags`/`positionalArgs`/`collectCliPositionals` (see `source-map.md`).
+ * Zero product nouns: callers declare which `--flag` names take a string
+ * value vs. are booleans, and get back a flat map plus the leftover
+ * positional tokens.
+ */
+/** A flag's value: `true` for a bare boolean flag, otherwise its string value. */
+export type FlagValue = string | boolean;
+/** The parsed `--flag`/`--flag=value` map produced by {@link parseFlags}. */
+export type ParsedFlags = Record<string, FlagValue>;
+export interface ParseFlagsOptions {
+    /** Flag names (without leading `--`) that always consume the next token as a string value. */
+    string?: ReadonlySet<string>;
+    /** Flag names (without leading `--`) that never consume a value — presence alone means `true`. */
+    boolean?: ReadonlySet<string>;
+}
+/**
+ * Parse `--flag value`, `--flag=value`, and bare boolean `--flag` tokens out
+ * of `argv`. Non-`--`-prefixed tokens (positionals) are silently skipped —
+ * use {@link positionalArgs} to collect those.
+ *
+ * When either `string` or `boolean` is non-empty, an unrecognized `--flag`
+ * throws (fail-fast: a hallucinated flag from an LLM-driven caller should
+ * error immediately rather than silently no-op). When both are empty, every
+ * `--flag` is accepted and a heuristic decides string-vs-boolean: if the
+ * next token doesn't itself look like a flag, it's consumed as the value.
+ */
+export declare function parseFlags(argv: readonly string[], opts?: ParseFlagsOptions): ParsedFlags;
+export interface PositionalArgsOptions {
+    /** String-valued flag names whose value token must be skipped, not collected as a positional. */
+    string?: ReadonlySet<string>;
+    /**
+     * When `true`, a bare `--` token stops flag-skipping and every remaining
+     * token (including ones that look like `--flags`) is collected verbatim.
+     * Mirrors the shell `--` convention (`collectCliPositionals` in the OD
+     * source). Defaults to `false`.
+     */
+    stopAtDoubleDash?: boolean;
+}
+/**
+ * Collect every non-flag token from `argv`, skipping the value token that
+ * follows a known string flag (so `od run start --project p1 foo` yields
+ * `['foo']`, not `['p1', 'foo']`).
+ */
+export declare function positionalArgs(argv: readonly string[], opts?: PositionalArgsOptions): string[];
+/** The native type {@link coerceCliValue} can produce from a raw string flag value. */
+export type CoercedCliValue = boolean | number | string;
+/**
+ * Coerce a raw `--flag <value>` string into its likely native type:
+ * `'true'`/`'false'` become booleans, a numeric-looking string becomes a
+ * `number`, and anything else passes through unchanged. Ported from OD's
+ * `cli.ts` `coerceCliValue` (see `source-map.md`) — used wherever a CLI
+ * accepts an untyped string flag value that application code should receive
+ * as its natural type (e.g. a config `set` command, or a plugin's dynamic
+ * `--input` flags forwarded as a JSON-typed payload).
+ */
+export declare function coerceCliValue(raw: string): CoercedCliValue;
+//# sourceMappingURL=flags.d.ts.map

package/dist/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../src/flags.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,kFAAkF;AAClF,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AAEzC,6EAA6E;AAC7E,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAEpD,MAAM,WAAW,iBAAiB;IAChC,8FAA8F;IAC9F,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,kGAAkG;IAClG,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,iBAAsB,GAAG,WAAW,CA4C7F;AAED,MAAM,WAAW,qBAAqB;IACpC,iGAAiG;IACjG,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,qBAA0B,GAAG,MAAM,EAAE,CAqBlG;AAED,uFAAuF;AACvF,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAIxD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAK3D"}

package/dist/flags.js

@@ -0,0 +1,111 @@
+/**
+ * @module flags
+ *
+ * Generic `argv` → flags parsing, ported from OD's `apps/daemon/src/cli.ts`
+ * `parseFlags`/`positionalArgs`/`collectCliPositionals` (see `source-map.md`).
+ * Zero product nouns: callers declare which `--flag` names take a string
+ * value vs. are booleans, and get back a flat map plus the leftover
+ * positional tokens.
+ */
+/**
+ * Parse `--flag value`, `--flag=value`, and bare boolean `--flag` tokens out
+ * of `argv`. Non-`--`-prefixed tokens (positionals) are silently skipped —
+ * use {@link positionalArgs} to collect those.
+ *
+ * When either `string` or `boolean` is non-empty, an unrecognized `--flag`
+ * throws (fail-fast: a hallucinated flag from an LLM-driven caller should
+ * error immediately rather than silently no-op). When both are empty, every
+ * `--flag` is accepted and a heuristic decides string-vs-boolean: if the
+ * next token doesn't itself look like a flag, it's consumed as the value.
+ */
+export function parseFlags(argv, opts = {}) {
+    const stringFlags = opts.string ?? new Set();
+    const booleanFlags = opts.boolean ?? new Set();
+    const knownFlags = new Set([...stringFlags, ...booleanFlags]);
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        // Loop is bounded by argv.length, so this index is always in range —
+        // noUncheckedIndexedAccess types it as possibly-undefined regardless.
+        const a = argv[i];
+        if (!a.startsWith('--'))
+            continue;
+        const eq = a.indexOf('=');
+        const key = eq >= 0 ? a.slice(2, eq) : a.slice(2);
+        if (knownFlags.size > 0 && !knownFlags.has(key)) {
+            throw new Error(`unknown flag: --${key}. Run with --help for the list of accepted flags.`);
+        }
+        if (eq >= 0) {
+            out[key] = a.slice(eq + 1);
+            continue;
+        }
+        if (booleanFlags.has(key)) {
+            out[key] = true;
+            continue;
+        }
+        if (stringFlags.has(key)) {
+            const next = argv[i + 1];
+            if (next === undefined) {
+                throw new Error(`flag --${key} requires a value`);
+            }
+            out[key] = next;
+            i++;
+            continue;
+        }
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('--')) {
+            out[key] = next;
+            i++;
+        }
+        else {
+            out[key] = true;
+        }
+    }
+    return out;
+}
+/**
+ * Collect every non-flag token from `argv`, skipping the value token that
+ * follows a known string flag (so `od run start --project p1 foo` yields
+ * `['foo']`, not `['p1', 'foo']`).
+ */
+export function positionalArgs(argv, opts = {}) {
+    const stringFlags = opts.string ?? new Set();
+    const out = [];
+    for (let i = 0; i < argv.length; i++) {
+        // Loop is bounded by argv.length, so this index is always in range —
+        // noUncheckedIndexedAccess types it as possibly-undefined regardless.
+        const a = argv[i];
+        if (opts.stopAtDoubleDash === true && a === '--') {
+            out.push(...argv.slice(i + 1));
+            break;
+        }
+        if (!a.startsWith('--')) {
+            out.push(a);
+            continue;
+        }
+        const eq = a.indexOf('=');
+        const key = eq >= 0 ? a.slice(2, eq) : a.slice(2);
+        if (eq < 0 && stringFlags.has(key))
+            i++;
+    }
+    return out;
+}
+const NUMERIC_LITERAL_RE = /^-?\d+(\.\d+)?$/;
+/**
+ * Coerce a raw `--flag <value>` string into its likely native type:
+ * `'true'`/`'false'` become booleans, a numeric-looking string becomes a
+ * `number`, and anything else passes through unchanged. Ported from OD's
+ * `cli.ts` `coerceCliValue` (see `source-map.md`) — used wherever a CLI
+ * accepts an untyped string flag value that application code should receive
+ * as its natural type (e.g. a config `set` command, or a plugin's dynamic
+ * `--input` flags forwarded as a JSON-typed payload).
+ */
+export function coerceCliValue(raw) {
+    if (raw === 'true')
+        return true;
+    if (raw === 'false')
+        return false;
+    if (NUMERIC_LITERAL_RE.test(raw))
+        return Number(raw);
+    return raw;
+}
+//# sourceMappingURL=flags.js.map

package/dist/flags.js.map

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

package/dist/http.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @module http
+ *
+ * HTTP-client-mode transport plumbing, ported from OD's
+ * `apps/daemon/src/cli.ts` `surfaceFetchError`/`postJsonToDaemon` (see
+ * `source-map.md`). This is the "HTTP-client mode default" half of
+ * extraction-plan §3's `@jini-ai/cli` spec: fetch a daemon route, translate a
+ * network failure or a daemon error envelope into the structured exit-code
+ * contract from `errors.ts`.
+ */
+import { type ExitCodeTable } from './errors.js';
+export interface SurfaceFetchErrorOptions {
+    /** Defaults to `process.stderr.write`; inject for tests. */
+    write?: (text: string) => void;
+}
+/**
+ * Format a `fetch()` rejection (network-unreachable, sandbox-denied) into a
+ * human-readable stderr line, with a hint when the underlying cause looks
+ * like a sandboxed-environment outbound-connect denial. Per CR-004/SEC-RB-009,
+ * `daemonUrl` and the failure detail are both sanitized before they reach
+ * stderr — a `daemonUrl` with embedded userinfo, or a cause message that
+ * embeds terminal control sequences or a leaked credential, must not be
+ * printed verbatim.
+ */
+export declare function surfaceFetchError(err: unknown, daemonUrl: string, options?: SurfaceFetchErrorOptions): void;
+export interface PostJsonToDaemonOptions {
+    headers?: Record<string, string>;
+    exitCodes?: ExitCodeTable;
+    /** Defaults to the global `fetch`; inject for tests. */
+    fetchImpl?: typeof fetch;
+    /** Defaults to `process.stderr.write`; inject for tests. Used only for the unrecognized-error-code fallback path. */
+    write?: (text: string) => void;
+    /** Defaults to `process.exit`; inject for tests (must not return). Used only for the unrecognized-error-code fallback path. */
+    exit?: (code: number) => never;
+    /** Caller-supplied cancellation signal; combined with the internal timeout signal, so either one aborts the request. */
+    signal?: AbortSignal;
+    /** Request deadline in ms. Defaults to {@link DEFAULT_TIMEOUT_MS}. */
+    timeoutMs?: number;
+    /** Maximum daemon response size in bytes before the read is aborted. Defaults to {@link DEFAULT_MAX_RESPONSE_BYTES}. */
+    maxResponseBytes?: number;
+}
+/** `GET`'s options are identical to {@link PostJsonToDaemonOptions} minus the (POST-only) request body. */
+export type GetJsonFromDaemonOptions = PostJsonToDaemonOptions;
+/**
+ * `POST` a JSON body to `<base><route>` and return the parsed JSON response.
+ * A network failure or a non-2xx daemon response both exit via the
+ * structured error contract (`errors.ts`) instead of returning — this
+ * function either resolves with the parsed body or never returns.
+ *
+ * Per CR-004/SEC-RB-009, this now enforces a request deadline (combined with
+ * an optional caller `signal`) and a maximum response size, and redacts
+ * daemon-supplied error detail before it reaches stderr instead of dumping
+ * it verbatim.
+ */
+export declare function postJsonToDaemon(base: string, route: string, body: unknown, options?: PostJsonToDaemonOptions): Promise<unknown>;
+/**
+ * `GET` `<base><route>` and return the parsed JSON response. Same transport contract as
+ * {@link postJsonToDaemon} (timeout, response-size cap, structured-error mapping, redaction) with
+ * no request body — for read-only daemon routes such as `@jini-ai/http`'s `GET /api/runs` and
+ * `GET /api/runs/:runId`.
+ */
+export declare function getJsonFromDaemon(base: string, route: string, options?: GetJsonFromDaemonOptions): Promise<unknown>;
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAwE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAIvH,MAAM,WAAW,wBAAwB;IACvC,4DAA4D;IAC5D,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,wBAA6B,GAAG,IAAI,CAsB/G;AA0ED,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,wDAAwD;IACxD,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB,qHAAqH;IACrH,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,+HAA+H;IAC/H,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC;IAC/B,wHAAwH;IACxH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wHAAwH;IACxH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,2GAA2G;AAC3G,MAAM,MAAM,wBAAwB,GAAG,uBAAuB,CAAC;AA+F/D;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,OAAO,CAAC,CAElB;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,OAAO,CAAC,CAElB"}