@agentuity/cli 3.0.0-alpha.7 → 3.0.0-beta.0

package/dist/node-compat/ansi.js

@@ -0,0 +1,128 @@
+/**
+ * ANSI / terminal-styling helpers.
+ *
+ * Replacements for the Bun-specific `Bun.color`, `Bun.stringWidth`,
+ * and `Bun.stripANSI` APIs used by `tui.ts` and `banner.ts`.
+ *
+ * - `color(spec, mode)` returns the SGR (Select Graphic Rendition)
+ *   escape that selects the given foreground color. Mirrors Bun's
+ *   `Bun.color('cyan', 'ansi-16m')` /
+ *   `Bun.color('#5C9CFF', 'ansi')` shape:
+ *   - `mode: 'ansi-16m'` -> 24-bit truecolor (`\\x1b[38;2;R;G;Bm`).
+ *     Wide compatibility on modern terminals.
+ *   - `mode: 'ansi'`    -> 16-color palette
+ *     (`\\x1b[3{0-7}m` / `\\x1b[9{0-7}m`). Use when the consumer
+ *     needs to land on dumb terminals.
+ *
+ * - `stringWidth(s)` is re-exported from the `string-width` npm
+ *   package. Inlining a correct implementation that handles emoji,
+ *   CJK, ZWJ sequences, and ANSI escapes is ~150 lines of edge
+ *   cases that the npm package already gets right.
+ *
+ * - `stripAnsi(s)` removes SGR (color/style) escape sequences. The
+ *   CLI only feeds this with logger output, so SGR-only stripping
+ *   suffices; we don't try to handle cursor or OSC codes.
+ */
+import stringWidthLib from 'string-width';
+/** Re-export of the `string-width` npm package's default export. */
+export const stringWidth = stringWidthLib;
+/**
+ * Return the SGR escape sequence that sets the foreground color to
+ * `spec` in the requested rendering `mode`. Returns an empty string
+ * if the spec cannot be resolved (rather than throwing) so callers
+ * can use the result inline without nesting null checks.
+ */
+export function color(spec, mode = 'ansi-16m') {
+    if (spec.startsWith('#')) {
+        const rgb = parseHex(spec);
+        if (!rgb)
+            return '';
+        if (mode === 'ansi') {
+            return ansi16FromRgb(rgb);
+        }
+        return ansi24FromRgb(rgb);
+    }
+    const named = NAMED_COLORS[spec];
+    if (!named)
+        return '';
+    if (mode === 'ansi') {
+        return `\x1b[${named.ansi}m`;
+    }
+    return ansi24FromRgb(named.rgb);
+}
+/**
+ * Strip SGR (color/style) escape sequences from `s`. Cursor /
+ * OSC / DCS sequences are left in place; the CLI doesn't generate
+ * them in places that flow through `stripAnsi`.
+ */
+export function stripAnsi(s) {
+    // Matches CSI ... m sequences (the SGR family). The leading 0x1b
+    // is the ESC byte; biome's noControlCharactersInRegex rule is off
+    // at the project level for this exact reason.
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+/**
+ * Subset of CSS named colors actually used by the CLI today. Each
+ * carries both its RGB triple (for 24-bit mode) and its 16-color
+ * SGR code (for `ansi` mode).
+ *
+ * If a future call site needs a color not listed here, add it to
+ * this map rather than falling back to a hex literal at the call
+ * site. Keeping the named-color list short is intentional.
+ */
+const NAMED_COLORS = {
+    black: { rgb: { r: 0, g: 0, b: 0 }, ansi: 30 },
+    red: { rgb: { r: 205, g: 49, b: 49 }, ansi: 31 },
+    green: { rgb: { r: 13, g: 188, b: 121 }, ansi: 32 },
+    yellow: { rgb: { r: 229, g: 229, b: 16 }, ansi: 33 },
+    blue: { rgb: { r: 36, g: 114, b: 200 }, ansi: 34 },
+    magenta: { rgb: { r: 188, g: 63, b: 188 }, ansi: 35 },
+    cyan: { rgb: { r: 17, g: 168, b: 205 }, ansi: 36 },
+    white: { rgb: { r: 229, g: 229, b: 229 }, ansi: 37 },
+    gray: { rgb: { r: 128, g: 128, b: 128 }, ansi: 90 },
+};
+function parseHex(hex) {
+    const cleaned = hex.startsWith('#') ? hex.slice(1) : hex;
+    if (cleaned.length === 3) {
+        const r = Number.parseInt(cleaned[0] + cleaned[0], 16);
+        const g = Number.parseInt(cleaned[1] + cleaned[1], 16);
+        const b = Number.parseInt(cleaned[2] + cleaned[2], 16);
+        if ([r, g, b].some(Number.isNaN))
+            return null;
+        return { r, g, b };
+    }
+    if (cleaned.length === 6) {
+        const r = Number.parseInt(cleaned.slice(0, 2), 16);
+        const g = Number.parseInt(cleaned.slice(2, 4), 16);
+        const b = Number.parseInt(cleaned.slice(4, 6), 16);
+        if ([r, g, b].some(Number.isNaN))
+            return null;
+        return { r, g, b };
+    }
+    return null;
+}
+function ansi24FromRgb({ r, g, b }) {
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+/**
+ * Approximate an arbitrary RGB triple to the closest of the 16
+ * basic ANSI colors. Uses Euclidean distance over the standard
+ * VGA-ish reference palette. Good enough for the few legacy
+ * call sites that still pass `mode: 'ansi'`.
+ */
+function ansi16FromRgb(rgb) {
+    let bestCode = 37;
+    let bestDist = Number.POSITIVE_INFINITY;
+    for (const named of Object.values(NAMED_COLORS)) {
+        const dr = rgb.r - named.rgb.r;
+        const dg = rgb.g - named.rgb.g;
+        const db = rgb.b - named.rgb.b;
+        const dist = dr * dr + dg * dg + db * db;
+        if (dist < bestDist) {
+            bestDist = dist;
+            bestCode = named.ansi;
+        }
+    }
+    return `\x1b[${bestCode}m`;
+}
+//# sourceMappingURL=ansi.js.map

package/dist/node-compat/ansi.js.map

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

package/dist/node-compat/crypto.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Project-domain hashing helper.
+ *
+ * Originally part of a broader crypto-shim layer that included
+ * `sha1Hex` / `sha256Hex` wrappers. Those have been inlined at their
+ * call sites (one each, both trivial `createHash(...).update(...).digest('hex')`).
+ *
+ * `shortHash16` survives because it encodes a project-specific
+ * decision: when we removed `Bun.hash.xxHash64` we needed a
+ * deterministic 16-hex-character replacement that produces the same
+ * string shape across runtimes. It's a SHA-256 truncation, but the
+ * truncation policy itself is the value the helper provides — pulling
+ * this into the call site would put a magic `.slice(0, 16)` in
+ * `domain.ts` without context.
+ *
+ * See PLAN.md §8 for the one-time cache-invalidation note: keys
+ * generated by this function will not match values previously
+ * generated by xxHash64 under Bun.
+ */
+/**
+ * Deterministic, 16-hex-character hash of a string. Backed by
+ * SHA-256 truncated to the first 16 hex digits.
+ *
+ * Replaces previous calls of the form
+ *   `Bun.hash.xxHash64(s).toString(16).padStart(16, '0')`
+ * with a Node-portable computation that produces a string of the
+ * same length and shape (16 lowercase hex chars).
+ */
+export declare function shortHash16(input: string | Uint8Array): string;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/node-compat/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/node-compat/crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAE9D"}

package/dist/node-compat/crypto.js

@@ -0,0 +1,33 @@
+/**
+ * Project-domain hashing helper.
+ *
+ * Originally part of a broader crypto-shim layer that included
+ * `sha1Hex` / `sha256Hex` wrappers. Those have been inlined at their
+ * call sites (one each, both trivial `createHash(...).update(...).digest('hex')`).
+ *
+ * `shortHash16` survives because it encodes a project-specific
+ * decision: when we removed `Bun.hash.xxHash64` we needed a
+ * deterministic 16-hex-character replacement that produces the same
+ * string shape across runtimes. It's a SHA-256 truncation, but the
+ * truncation policy itself is the value the helper provides — pulling
+ * this into the call site would put a magic `.slice(0, 16)` in
+ * `domain.ts` without context.
+ *
+ * See PLAN.md §8 for the one-time cache-invalidation note: keys
+ * generated by this function will not match values previously
+ * generated by xxHash64 under Bun.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * Deterministic, 16-hex-character hash of a string. Backed by
+ * SHA-256 truncated to the first 16 hex digits.
+ *
+ * Replaces previous calls of the form
+ *   `Bun.hash.xxHash64(s).toString(16).padStart(16, '0')`
+ * with a Node-portable computation that produces a string of the
+ * same length and shape (16 lowercase hex chars).
+ */
+export function shortHash16(input) {
+    return createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+//# sourceMappingURL=crypto.js.map

package/dist/node-compat/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../src/node-compat/crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,KAA0B;IACrD,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACtE,CAAC"}

package/dist/node-compat/fs.d.ts

@@ -0,0 +1,31 @@
+/**
+ * File system shims.
+ *
+ * The trivial pass-throughs (readText, readJson, writeText, etc.)
+ * have been inlined at their call sites — `await readFile(p, 'utf-8')`
+ * is no harder to read than `readText(p)` and saves an import.
+ *
+ * What survives are the two helpers that are genuinely awkward inline:
+ *
+ *   - `pathExists` — Node's `node:fs` has no boolean-returning
+ *     existence check; the canonical idiom
+ *     `await access(p).then(() => true).catch(() => false)` is ugly
+ *     enough that centralizing it pays off across ~30 call sites.
+ *   - `openReadStream` — opens a file and returns a Web
+ *     `ReadableStream<Uint8Array>` (rather than a Node `Readable`)
+ *     so callers can pipe it directly into `fetch` bodies, our
+ *     `S3ClientLike.write`, etc. The `Readable.toWeb` cast dance is
+ *     not something every call site needs to know about.
+ */
+/**
+ * Returns whether the path exists and is reachable. Wraps
+ * `access(p, F_OK)`; any error is treated as "does not exist".
+ */
+export declare function pathExists(path: string): Promise<boolean>;
+/**
+ * Open a file for streaming reads. Returns a Web `ReadableStream` so
+ * the result can be passed to `fetch` bodies, our `S3ClientLike.write`,
+ * etc. Closes automatically when the consumer finishes reading.
+ */
+export declare function openReadStream(path: string): ReadableStream<Uint8Array>;
+//# sourceMappingURL=fs.d.ts.map

package/dist/node-compat/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../src/node-compat/fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH;;;GAGG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO/D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAC,UAAU,CAAC,CAIvE"}

package/dist/node-compat/fs.js

@@ -0,0 +1,44 @@
+/**
+ * File system shims.
+ *
+ * The trivial pass-throughs (readText, readJson, writeText, etc.)
+ * have been inlined at their call sites — `await readFile(p, 'utf-8')`
+ * is no harder to read than `readText(p)` and saves an import.
+ *
+ * What survives are the two helpers that are genuinely awkward inline:
+ *
+ *   - `pathExists` — Node's `node:fs` has no boolean-returning
+ *     existence check; the canonical idiom
+ *     `await access(p).then(() => true).catch(() => false)` is ugly
+ *     enough that centralizing it pays off across ~30 call sites.
+ *   - `openReadStream` — opens a file and returns a Web
+ *     `ReadableStream<Uint8Array>` (rather than a Node `Readable`)
+ *     so callers can pipe it directly into `fetch` bodies, our
+ *     `S3ClientLike.write`, etc. The `Readable.toWeb` cast dance is
+ *     not something every call site needs to know about.
+ */
+import { createReadStream } from 'node:fs';
+import { access } from 'node:fs/promises';
+import { Readable } from 'node:stream';
+/**
+ * Returns whether the path exists and is reachable. Wraps
+ * `access(p, F_OK)`; any error is treated as "does not exist".
+ */
+export async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Open a file for streaming reads. Returns a Web `ReadableStream` so
+ * the result can be passed to `fetch` bodies, our `S3ClientLike.write`,
+ * etc. Closes automatically when the consumer finishes reading.
+ */
+export function openReadStream(path) {
+    return Readable.toWeb(createReadStream(path));
+}
+//# sourceMappingURL=fs.js.map

package/dist/node-compat/fs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.js","sourceRoot":"","sources":["../../src/node-compat/fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,IAAY;IAC5C,IAAI,CAAC;QACJ,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC;QACnB,OAAO,IAAI,CAAC;IACb,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,KAAK,CAAC;IACd,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IAC1C,OAAO,QAAQ,CAAC,KAAK,CACpB,gBAAgB,CAAC,IAAI,CAAC,CACwD,CAAC;AACjF,CAAC"}

package/dist/node-compat/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Node-compatibility shim layer for `@agentuity/cli`.
+ *
+ * Each submodule in this directory wraps a Bun-specific API with a
+ * Node 24+ native equivalent (or a small npm dependency where native
+ * parity is genuinely missing). Callers import from the specific
+ * submodule, never via a `Bun.X` global, so the CLI source is portable
+ * across runtimes.
+ *
+ * This barrel re-exports everything for callers who prefer a single
+ * import line, but most call sites should import directly from the
+ * submodule for clearer dependencies and smaller IDE auto-import
+ * suggestions.
+ *
+ * Phase 5 of the migration plan reduced the number of shims kept here:
+ * the trivial wrappers (sleep, parseYaml/stringifyYaml, sha1Hex,
+ * sha256Hex, plus several thin fs helpers) were inlined at their call
+ * sites because the Node native idiom is essentially as readable as
+ * the shim. What survives below is the genuinely-non-trivial group —
+ * helpers that either encode project-specific semantics or
+ * substantially reduce verbosity.
+ */
+export { pathExists, openReadStream } from './fs.ts';
+export { run, spawnInherit, spawnDetached, spawnStreamingOutput, type ProcOptions, type RunResult, type SpawnInheritResult, } from './proc.ts';
+export { which } from './which.ts';
+export { shortHash16 } from './crypto.ts';
+export { readStdinText, stdinWebStream } from './stdin.ts';
+export { runtimeKind, runtimeVersion, entryScriptPath, currentDir, gitSha, type RuntimeKind, } from './runtime-info.ts';
+export { color, stripAnsi, stringWidth, type ColorMode, type ColorSpec, } from './ansi.ts';
+export { openDatabase, type Database, type Statement } from './sqlite.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/node-compat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/node-compat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAErD,OAAO,EACN,GAAG,EACH,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,kBAAkB,GACvB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE3D,OAAO,EACN,WAAW,EACX,cAAc,EACd,eAAe,EACf,UAAU,EACV,MAAM,EACN,KAAK,WAAW,GAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACN,KAAK,EACL,SAAS,EACT,WAAW,EACX,KAAK,SAAS,EACd,KAAK,SAAS,GACd,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,YAAY,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/node-compat/index.js

@@ -0,0 +1,31 @@
+/**
+ * Node-compatibility shim layer for `@agentuity/cli`.
+ *
+ * Each submodule in this directory wraps a Bun-specific API with a
+ * Node 24+ native equivalent (or a small npm dependency where native
+ * parity is genuinely missing). Callers import from the specific
+ * submodule, never via a `Bun.X` global, so the CLI source is portable
+ * across runtimes.
+ *
+ * This barrel re-exports everything for callers who prefer a single
+ * import line, but most call sites should import directly from the
+ * submodule for clearer dependencies and smaller IDE auto-import
+ * suggestions.
+ *
+ * Phase 5 of the migration plan reduced the number of shims kept here:
+ * the trivial wrappers (sleep, parseYaml/stringifyYaml, sha1Hex,
+ * sha256Hex, plus several thin fs helpers) were inlined at their call
+ * sites because the Node native idiom is essentially as readable as
+ * the shim. What survives below is the genuinely-non-trivial group —
+ * helpers that either encode project-specific semantics or
+ * substantially reduce verbosity.
+ */
+export { pathExists, openReadStream } from "./fs.js";
+export { run, spawnInherit, spawnDetached, spawnStreamingOutput, } from "./proc.js";
+export { which } from "./which.js";
+export { shortHash16 } from "./crypto.js";
+export { readStdinText, stdinWebStream } from "./stdin.js";
+export { runtimeKind, runtimeVersion, entryScriptPath, currentDir, gitSha, } from "./runtime-info.js";
+export { color, stripAnsi, stringWidth, } from "./ansi.js";
+export { openDatabase } from "./sqlite.js";
+//# sourceMappingURL=index.js.map

package/dist/node-compat/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/node-compat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAErD,OAAO,EACN,GAAG,EACH,YAAY,EACZ,aAAa,EACb,oBAAoB,GAIpB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE3D,OAAO,EACN,WAAW,EACX,cAAc,EACd,eAAe,EACf,UAAU,EACV,MAAM,GAEN,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACN,KAAK,EACL,SAAS,EACT,WAAW,GAGX,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,YAAY,EAAiC,MAAM,aAAa,CAAC"}

package/dist/node-compat/proc.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Process spawning primitives for `@agentuity/cli`.
+ *
+ * Replaces direct `Bun.spawn(...)` / `Bun.spawnSync(...)` calls. Two
+ * shapes cover ~95% of the CLI's needs:
+ *
+ *   - `run(opts)` — capture-mode. Spawns a command, waits for exit,
+ *     returns `{ exitCode, stdout, stderr }`. Use this when the
+ *     caller wants the output as strings.
+ *
+ *   - `spawnInherit(opts)` — passthrough-mode. Spawns a command with
+ *     stdio inherited from the parent (so the child draws to the
+ *     same TTY), waits for exit, returns `{ exitCode }`. Use this
+ *     for interactive subprocesses (`ssh`, `scp`, the user's dev
+ *     server, etc.).
+ *
+ * Why a thin layer:
+ *
+ * - `Bun.spawn`'s API uses `{ cmd: [...], cwd, env, stdout, stderr,
+ *   stdin }` with stdio mode names (`'inherit'`, `'pipe'`, `'ignore'`).
+ *   `child_process.spawn` takes `(command, args, options)` with a
+ *   single `stdio` triple. Translating is mechanical but verbose.
+ * - `Bun.spawn`'s `proc.exited` resolves to the exit code; on Node
+ *   we have to wire up the `'exit'` / `'close'` events ourselves.
+ * - Capture-mode (`stdout: 'pipe'` then `proc.stdout.text()`) needs
+ *   an explicit `streamConsumers.text(...)` on Node.
+ *
+ * Centralizing all of this keeps callers in plain
+ * `await run({ cmd: [...] })` / `await spawnInherit({ cmd: [...] })`
+ * shape regardless of runtime.
+ */
+import { type ChildProcess } from 'node:child_process';
+/** Options for `run()` and `spawnInherit()`. */
+export interface ProcOptions {
+    /** Command and arguments. `cmd[0]` is the executable. */
+    cmd: string[];
+    /** Working directory. Defaults to the current process cwd. */
+    cwd?: string;
+    /** Additional / overriding environment variables. Merged onto `process.env`. */
+    env?: Record<string, string | undefined>;
+    /**
+     * Optional input to write to the child's stdin before reading
+     * stdout. If provided, stdin is opened in pipe mode regardless of
+     * other settings.
+     */
+    stdin?: string | Buffer | Uint8Array;
+    /**
+     * Whether to merge `process.env` with `env`. Defaults to `true`.
+     * Set to `false` to launch with only the explicit env (rare; use
+     * for hermetic invocations).
+     */
+    inheritEnv?: boolean;
+    /**
+     * Soft timeout in milliseconds. If exceeded, the child is sent
+     * SIGTERM, then SIGKILL after a grace period. The returned
+     * `timedOut` flag indicates whether the timeout fired.
+     */
+    timeoutMs?: number;
+}
+/** Result of a `run()` call. */
+export interface RunResult {
+    /** Exit code, or `null` if the process was killed by a signal. */
+    exitCode: number | null;
+    /** Captured standard output, decoded as UTF-8. */
+    stdout: string;
+    /** Captured standard error, decoded as UTF-8. */
+    stderr: string;
+    /** True if the process was killed by `timeoutMs`. */
+    timedOut: boolean;
+}
+/** Result of a `spawnInherit()` call. */
+export interface SpawnInheritResult {
+    exitCode: number | null;
+}
+/**
+ * Spawn a process, capture its stdout/stderr, and wait for exit.
+ *
+ * Equivalent to Bun's
+ *   `const p = Bun.spawn({ cmd, stdout: 'pipe', stderr: 'pipe' });
+ *    const stdout = await new Response(p.stdout).text();
+ *    const exitCode = await p.exited;`
+ * but factored so each call site stays one line.
+ */
+export declare function run(opts: ProcOptions): Promise<RunResult>;
+/**
+ * Spawn a process with stdio inherited from the parent and wait for
+ * exit. Use this for interactive subprocesses (ssh, scp, the user's
+ * dev server) where the child should draw directly to the user's
+ * terminal.
+ */
+export declare function spawnInherit(opts: ProcOptions): Promise<SpawnInheritResult>;
+/**
+ * Spawn a process detached, ignoring stdio. Caller does not wait for
+ * exit. Returns the underlying `ChildProcess` handle in case the
+ * caller wants to track it.
+ *
+ * Used for "open this URL in the browser" / "open this file in the
+ * default app" kinds of operations where we want to fire-and-forget.
+ */
+export declare function spawnDetached(opts: Omit<ProcOptions, 'stdin' | 'timeoutMs'>): ChildProcess;
+/**
+ * Spawn a process and expose its stdout/stderr as Web
+ * `ReadableStream<Uint8Array>`s for the caller to consume
+ * incrementally. Use this when the caller wants to render output
+ * progressively (e.g. a TUI spinner that shows the latest stderr
+ * line). Returns a promise that resolves to the final exit code
+ * once both streams have closed.
+ *
+ * Note: callers must `await exited` after they finish reading the
+ * streams, otherwise the child may stay live indefinitely (the OS
+ * pipe stays open).
+ */
+export declare function spawnStreamingOutput(opts: Omit<ProcOptions, 'stdin' | 'timeoutMs'>): {
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    exited: Promise<{
+        exitCode: number | null;
+    }>;
+};
+//# sourceMappingURL=proc.d.ts.map

package/dist/node-compat/proc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proc.d.ts","sourceRoot":"","sources":["../../src/node-compat/proc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAS,KAAK,YAAY,EAAqB,MAAM,oBAAoB,CAAC;AAMjF,gDAAgD;AAChD,MAAM,WAAW,WAAW;IAC3B,yDAAyD;IACzD,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,8DAA8D;IAC9D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IACzC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC;IACrC;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,gCAAgC;AAChC,MAAM,WAAW,SAAS;IACzB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED,yCAAyC;AACzC,MAAM,WAAW,kBAAkB;IAClC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAsB,GAAG,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAuB/D;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAYjF;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC,GAAG,YAAY,CAe1F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC,GAAG;IACrF,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IACnC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IACnC,MAAM,EAAE,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;CAC7C,CAqBA"}