@dbx-tools/core 0.3.44 → 0.4.1

package/lib/src/exec.js

@@ -0,0 +1,483 @@
+/**
+ * Portable subprocess helper built on `child_process.spawn` and line streaming.
+ *
+ * Ported from `dbx-tools-js/packages/cli/src/exec.ts`. Each stdio fd defaults to
+ * `"inherit"`. {@link spawn} streams output line-by-line into {@link ExecResult.stdoutLines}
+ * / {@link ExecResult.stderrLines}; its `stdout` / `stderr` getters join those lines.
+ * {@link spawnSync} keeps the captured string; its `stdout` / `stderr` getters read
+ * that string directly (line arrays split lazily on read).
+ * Omitted `trim` (default) applies adaptive normalization: {@link spawnSync} drops
+ * at most one trailing empty line / newline `spawnSync` adds; {@link spawn} does
+ * not (readline never emits that extra line). `trim: true` strips all leading/
+ * trailing whitespace in both modes; `trim: false` leaves output unchanged.
+ *
+ * @example Capture command output
+ * ```ts
+ * const { stdout } = await exec("git", ["rev-parse", "--show-toplevel"], {
+ *   stdout: "capture",
+ *   stderr: "ignore",
+ *   stdin: "ignore",
+ * });
+ * ```
+ *
+ * @example Stream and capture together
+ * ```ts
+ * await exec("pnpm", ["install"], {
+ *   stdout: [(line) => console.log(line), "capture"],
+ *   check: true,
+ * });
+ * ```
+ *
+ * @example Synchronous capture (no line callbacks)
+ * ```ts
+ * const { stdout } = execSync("git", ["rev-parse", "--show-toplevel"], {
+ *   stdout: "capture",
+ *   stderr: "ignore",
+ *   stdin: "ignore",
+ * });
+ * ```
+ *
+ * @module
+ */
+import { spawn as nodeSpawn, spawnSync as nodeSpawnSync, } from "node:child_process";
+import * as readline from "node:readline";
+function parseSpawnArgs(input) {
+    let [value, ...values] = input;
+    const [command, ...commandArgs] = shlex(value);
+    if (commandArgs.length == 1 && values.length === 0) {
+        return {
+            command,
+            commandArgs: [],
+        };
+    }
+    const last = values.at(-1);
+    const options = last !== null && typeof last === "object" && !Array.isArray(last) ? last : undefined;
+    const argumentValues = options ? values.slice(0, -1) : values;
+    const valueArgs = argumentValues.length === 1 && Array.isArray(argumentValues[0])
+        ? [...argumentValues[0]]
+        : argumentValues;
+    return {
+        command,
+        commandArgs: [...commandArgs, ...valueArgs],
+        options: options,
+    };
+}
+/**
+ * Drop the single trailing empty entry `spawnSync` adds when splitting on a final
+ * newline (`"hi\n"` -> `["hi", ""]`). Does not remove multiple trailing empties.
+ */
+function withoutSpawnTrailingEmptyLine(lines) {
+    if (lines.length > 0 && lines[lines.length - 1] === "") {
+        return lines.slice(0, -1);
+    }
+    return lines;
+}
+/** Remove at most one trailing newline from captured spawn stdout/stderr text. */
+function trimSingleTrailingNewline(text) {
+    if (text.endsWith("\r\n"))
+        return text.slice(0, -2);
+    if (text.endsWith("\n"))
+        return text.slice(0, -1);
+    return text;
+}
+/** Line-array view of async-captured output. */
+function normalizedAsyncLines(lines, trim) {
+    if (trim === true)
+        return linesFromCapturedOutput(lines.join("\n").trim());
+    return lines;
+}
+/** Join async-captured lines into stdout/stderr text. */
+function formatAsyncCapturedLines(lines, trim) {
+    const joined = lines.join("\n");
+    return trim === true ? joined.trim() : joined;
+}
+/** Line-array view of sync-captured output. */
+function normalizedSyncLines(lines, trim) {
+    if (trim === false)
+        return lines;
+    if (trim === true)
+        return linesFromCapturedOutput(lines.join("\n").trim());
+    return withoutSpawnTrailingEmptyLine(lines);
+}
+/** Format sync-captured stdout/stderr text. */
+function formatSyncCapturedText(text, trim) {
+    if (text === undefined)
+        return undefined;
+    if (trim === false)
+        return text;
+    if (trim === true)
+        return text.trim();
+    return trimSingleTrailingNewline(text);
+}
+/**
+ * Human-readable label for a spawned command, used in error messages.
+ *
+ * @param command - Executable name or path
+ * @param args - Arguments passed to the executable
+ * @returns Backtick-wrapped `command arg1 arg2 ...` string
+ */
+function commandLabel(command, args) {
+    return `\`${command} ${args.join(" ")}\``;
+}
+/**
+ * Build the object returned from {@link spawn} with live line arrays and lazy
+ * trimmed `stdout` / `stderr` getters derived from those lines.
+ */
+function createExecResult(exitCode, stdoutLines, stderrLines, trim) {
+    return {
+        exitCode,
+        get stdoutLines() {
+            return normalizedAsyncLines(stdoutLines, trim);
+        },
+        get stderrLines() {
+            return normalizedAsyncLines(stderrLines, trim);
+        },
+        get stdout() {
+            return formatAsyncCapturedLines(stdoutLines, trim);
+        },
+        get stderr() {
+            return formatAsyncCapturedLines(stderrLines, trim);
+        },
+    };
+}
+/**
+ * Build the object returned from {@link spawnSync}. Captured strings are stored
+ * as-is; `stdout` / `stderr` trim directly, and line arrays split only on read.
+ */
+function createSyncExecResult(exitCode, stdoutText, stderrText, trim) {
+    let stdoutLinesCache;
+    let stderrLinesCache;
+    const syncLines = (text) => {
+        if (text === undefined)
+            return undefined;
+        return normalizedSyncLines(linesFromCapturedOutput(text), trim);
+    };
+    return {
+        exitCode,
+        get stdoutLines() {
+            if (stdoutText === undefined)
+                return [];
+            stdoutLinesCache ??= syncLines(stdoutText) ?? [];
+            return stdoutLinesCache;
+        },
+        get stderrLines() {
+            if (stderrText === undefined)
+                return [];
+            stderrLinesCache ??= syncLines(stderrText) ?? [];
+            return stderrLinesCache;
+        },
+        get stdout() {
+            return formatSyncCapturedText(stdoutText, trim) ?? "";
+        },
+        get stderr() {
+            return formatSyncCapturedText(stderrText, trim) ?? "";
+        },
+    };
+}
+/**
+ * Extract user-supplied line handlers from a {@link StdioOption}.
+ *
+ * The `"capture"` marker is filtered out; capture itself is always handled by
+ * pushing into the line buffer inside {@link resolveStdio}.
+ *
+ * @param option - Stdio option that may embed one or more handlers
+ * @returns Handlers to invoke after each captured line (may be empty)
+ */
+function lineHandlers(option) {
+    if (typeof option === "function")
+        return [option];
+    if (Array.isArray(option)) {
+        return option.filter((item) => item !== "capture");
+    }
+    return [];
+}
+/**
+ * True when a stdio option is a string spawn mode rather than capture/handlers.
+ *
+ * {@link resolveStdio} still treats `"pipe"` as pipe-and-capture; only
+ * `"inherit"` and `"ignore"` return without a line callback.
+ *
+ * @param option - Stdio option to classify
+ * @returns Whether `option` is `"inherit"`, `"pipe"`, or `"ignore"`
+ */
+function isPassthroughMode(option) {
+    return option === "inherit" || option === "pipe" || option === "ignore";
+}
+/**
+ * Map a {@link StdioOption} into a spawn stdio mode and optional line callback.
+ *
+ * Piped modes (`"capture"`, `"pipe"`, handlers, arrays) append every line to
+ * `lines` and invoke any embedded handlers. Omitted options use `defaultMode`.
+ *
+ * @param option - Caller stdio preference for one fd
+ * @param lines - Mutable buffer that receives each piped line
+ * @param defaultMode - Spawn mode when `option` is omitted (`"inherit"` by default)
+ * @returns Resolved spawn mode and optional per-line callback
+ */
+function resolveStdio(option, lines, defaultMode = "inherit") {
+    if (option === undefined)
+        return { mode: defaultMode };
+    if (isPassthroughMode(option) && option !== "pipe")
+        return { mode: option };
+    const handlers = lineHandlers(option);
+    return {
+        mode: "pipe",
+        onLine: (line) => {
+            lines.push(line);
+            for (const handler of handlers)
+                handler(line);
+        },
+    };
+}
+/**
+ * Read a readable stream line-by-line and invoke `onLine` for each chunk.
+ *
+ * Uses `readline` so `\r\n` and bare `\n` are normalized. The interface is
+ * always closed in a `finally` block.
+ *
+ * @param stream - Subprocess stdout or stderr stream
+ * @param onLine - Callback invoked once per output line
+ */
+async function readLines(stream, onLine) {
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+        for await (const line of rl)
+            onLine(line);
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Start a background line read when the resolved handler pipes a stream.
+ *
+ * @param reads - Promise list awaited before returning the {@link ExecResult}
+ * @param stream - Subprocess stream for this fd (`null` when unavailable)
+ * @param handler - Resolved stdio config from {@link resolveStdio}
+ */
+function queueLineReads(reads, stream, handler) {
+    if (handler.onLine && stream)
+        reads.push(readLines(stream, handler.onLine));
+}
+/**
+ * Write string stdin to a spawned process and close the stream.
+ *
+ * No-op unless `stdin` is a string and `proc.stdin` is available.
+ *
+ * @param proc - Child process returned from `spawn`
+ * @param stdin - Stdio mode or string payload from {@link ExecOptions}
+ */
+function writeStdin(proc, stdin) {
+    if (typeof stdin === "string" && proc.stdin) {
+        proc.stdin.write(stdin);
+        proc.stdin.end();
+    }
+}
+/**
+ * Await process exit and normalize a missing exit code to `1`.
+ *
+ * Rejects when spawn fails before `close` (e.g. executable not found).
+ *
+ * @param proc - Child process returned from `spawn`
+ * @returns Resolved exit code
+ */
+function waitForExit(proc) {
+    return new Promise((resolve, reject) => {
+        proc.once("error", reject);
+        proc.once("close", (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * Build an `Error` for a non-zero exit when {@link ExecOptions.check} is set.
+ *
+ * Prefers trimmed stderr text, then stdout, in the message body.
+ *
+ * @param command - Executable name or path
+ * @param args - Arguments passed to the executable
+ * @param result - Completed exec outcome with captured output
+ * @returns Error suitable for throwing from {@link spawn}
+ */
+function execError(command, args, result) {
+    const detail = result.stderr || result.stdout;
+    return new Error(`${commandLabel(command, args)} failed (exit ${result.exitCode})${detail ? `: ${detail}` : ""}`);
+}
+/**
+ * Map a {@link SyncExecStdio} option to a `spawnSync` stdio mode.
+ *
+ * `"capture"` pipes the fd so output can be read into the {@link ExecResult}.
+ *
+ * @param option - Caller stdio preference for one fd
+ * @param defaultMode - Spawn mode when `option` is omitted (`"inherit"` by default)
+ * @returns Value for the `spawnSync` stdio tuple
+ */
+function resolveSyncStdio(option, defaultMode = "inherit") {
+    if (option === undefined)
+        return defaultMode;
+    if (option === "capture")
+        return "pipe";
+    return option;
+}
+/**
+ * Normalize raw `spawnSync` output to a UTF-8 string when capture is enabled.
+ */
+function capturedText(output) {
+    if (output === null || output === undefined)
+        return undefined;
+    return typeof output === "string" ? output : output.toString("utf8");
+}
+/**
+ * Split captured process output into lines for {@link ExecResult.stdoutLines} /
+ * {@link ExecResult.stderrLines} ({@link spawnSync} only; invoked lazily).
+ */
+function linesFromCapturedOutput(output) {
+    return output.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+}
+/**
+ * Spawn a subprocess and wait for exit.
+ *
+ * @param command - Executable to run (resolved on `PATH` when `shell` is set on options)
+ * @param args - Arguments passed verbatim to the executable
+ * @param options - Spawn, stdio, and check options
+ * @returns Exit code, captured line arrays, and trimmed `stdout` / `stderr` getters
+ * @throws When spawn fails, line reads fail, or `check` is true and exit code is non-zero
+ */
+export async function spawn(...args) {
+    const { command, commandArgs, options = {} } = parseSpawnArgs(args);
+    const { stdin, stdout, stderr, check, trim, ...spawnOpts } = options;
+    const stdoutLines = [];
+    const stderrLines = [];
+    const stdoutHandler = resolveStdio(stdout, stdoutLines);
+    const stderrHandler = resolveStdio(stderr, stderrLines);
+    const stdinMode = typeof stdin === "string" ? "pipe" : (stdin ?? "inherit");
+    const proc = nodeSpawn(command, commandArgs, {
+        ...spawnOpts,
+        stdio: [stdinMode, stdoutHandler.mode, stderrHandler.mode],
+    });
+    writeStdin(proc, stdin);
+    const reads = [];
+    queueLineReads(reads, proc.stdout, stdoutHandler);
+    queueLineReads(reads, proc.stderr, stderrHandler);
+    let exitCode = 1;
+    try {
+        exitCode = await waitForExit(proc);
+        await Promise.all(reads);
+    }
+    catch (err) {
+        await Promise.allSettled(reads);
+        throw err;
+    }
+    const result = createExecResult(exitCode, stdoutLines, stderrLines, trim);
+    if (check && result.exitCode !== 0)
+        throw execError(command, commandArgs, result);
+    return result;
+}
+/**
+ * Spawn a subprocess synchronously and wait for exit.
+ *
+ * Unlike {@link spawn}, stdio options are limited to `"inherit"`, `"pipe"`,
+ * `"ignore"`, and `"capture"` — no per-line callbacks.
+ *
+ * @param command - Executable to run (resolved on `PATH` when `shell` is set on options)
+ * @param args - Arguments passed verbatim to the executable
+ * @param spawnSync - Spawn, stdio, and check options
+ * @returns Exit code, captured line arrays, and trimmed `stdout` / `stderr` getters
+ * @throws When spawn fails or `check` is true and exit code is non-zero
+ */
+export function spawnSync(...args) {
+    const { command, commandArgs, options = {} } = parseSpawnArgs(args);
+    const { stdin, stdout, stderr, check, trim, ...spawnOpts } = options;
+    const stdinMode = typeof stdin === "string" ? "pipe" : (stdin ?? "inherit");
+    const captureStdout = stdout === "capture";
+    const captureStderr = stderr === "capture";
+    const stdoutMode = resolveSyncStdio(stdout);
+    const stderrMode = resolveSyncStdio(stderr);
+    const result = nodeSpawnSync(command, commandArgs, {
+        ...spawnOpts,
+        encoding: captureStdout || captureStderr ? "utf8" : undefined,
+        stdio: [stdinMode, stdoutMode, stderrMode],
+        input: typeof stdin === "string" ? stdin : undefined,
+    });
+    const exitCode = result.status ?? 1;
+    const stdoutText = captureStdout ? capturedText(result.stdout) : undefined;
+    const stderrText = captureStderr ? capturedText(result.stderr) : undefined;
+    const execResult = createSyncExecResult(exitCode, stdoutText, stderrText, trim);
+    if (result.error) {
+        if (check || execResult.exitCode !== 0) {
+            const err = execError(command, commandArgs, execResult);
+            err.cause = result.error;
+            throw err;
+        }
+    }
+    if (check && execResult.exitCode !== 0)
+        throw execError(command, commandArgs, execResult);
+    return execResult;
+}
+/**
+ * Splits a shell-like command into argv.
+ *
+ * Supports:
+ *   - whitespace separators
+ *   - single and double quotes
+ *   - backslash escaping
+ *   - escaped spaces
+ *   - empty quoted strings
+ *
+ * If the input is malformed (for example, an unterminated quote),
+ * returns the original string as a single argument.
+ */
+export function shlex(command) {
+    const args = [];
+    let current = "";
+    let quote;
+    let escaped = false;
+    let quoted = false;
+    const push = () => {
+        if (quoted || current.length > 0) {
+            args.push(current);
+        }
+        current = "";
+        quoted = false;
+    };
+    for (const ch of command) {
+        if (escaped) {
+            current += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote) {
+                quote = undefined;
+                quoted = true;
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            quoted = true;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            push();
+            continue;
+        }
+        current += ch;
+    }
+    // Malformed input: treat as a literal command.
+    if (quote) {
+        return [command];
+    }
+    // Trailing backslash is literal.
+    if (escaped) {
+        current += "\\";
+    }
+    push();
+    return args.length ? args : [command];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exec.js","sourceRoot":"","sources":["../../src/exec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,EAGL,KAAK,IAAI,SAAS,EAClB,SAAS,IAAI,aAAa,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAsG1C,SAAS,cAAc,CAAyB,KAAmB;IACjE,IAAI,CAAC,KAAK,EAAE,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC;IAC/B,MAAM,CAAC,OAAO,EAAE,GAAG,WAAW,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/C,IAAI,WAAW,CAAC,MAAM,IAAI,CAAC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACnD,OAAO;YACL,OAAO;YACP,WAAW,EAAE,EAAE;SAChB,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,MAAM,OAAO,GACX,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACvF,MAAM,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAC9D,MAAM,SAAS,GACb,cAAc,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC,CAAC,cAAc,CAAC;IAErB,OAAO;QACL,OAAO;QACP,WAAW,EAAE,CAAC,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC;QAC3C,OAAO,EAAE,OAAY;KACtB,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,6BAA6B,CAAC,KAAwB;IAC7D,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;QACvD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,KAAiB,CAAC;AAC3B,CAAC;AAED,kFAAkF;AAClF,SAAS,yBAAyB,CAAC,IAAY;IAC7C,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACpD,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAClD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,gDAAgD;AAChD,SAAS,oBAAoB,CAAC,KAAwB,EAAE,IAAyB;IAC/E,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,uBAAuB,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3E,OAAO,KAAiB,CAAC;AAC3B,CAAC;AAED,yDAAyD;AACzD,SAAS,wBAAwB,CAAC,KAAwB,EAAE,IAAyB;IACnF,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,OAAO,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;AAChD,CAAC;AAED,+CAA+C;AAC/C,SAAS,mBAAmB,CAAC,KAAwB,EAAE,IAAyB;IAC9E,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,KAAiB,CAAC;IAC7C,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,uBAAuB,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3E,OAAO,6BAA6B,CAAC,KAAK,CAAC,CAAC;AAC9C,CAAC;AAED,+CAA+C;AAC/C,SAAS,sBAAsB,CAC7B,IAAwB,EACxB,IAAyB;IAEzB,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACzC,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,IAAI,CAAC;IAChC,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;IACtC,OAAO,yBAAyB,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,OAAe,EAAE,IAAc;IACnD,OAAO,KAAK,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;AAC5C,CAAC;AAED;;;GAGG;AACH,SAAS,gBAAgB,CACvB,QAAgB,EAChB,WAAqB,EACrB,WAAqB,EACrB,IAAyB;IAEzB,OAAO;QACL,QAAQ;QACR,IAAI,WAAW;YACb,OAAO,oBAAoB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACjD,CAAC;QACD,IAAI,WAAW;YACb,OAAO,oBAAoB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACjD,CAAC;QACD,IAAI,MAAM;YACR,OAAO,wBAAwB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC;QACD,IAAI,MAAM;YACR,OAAO,wBAAwB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB,CAC3B,QAAgB,EAChB,UAA8B,EAC9B,UAA8B,EAC9B,IAAyB;IAEzB,IAAI,gBAAsC,CAAC;IAC3C,IAAI,gBAAsC,CAAC;IAE3C,MAAM,SAAS,GAAG,CAAC,IAAwB,EAAwB,EAAE;QACnE,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QACzC,OAAO,mBAAmB,CAAC,uBAAuB,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;IAClE,CAAC,CAAC;IAEF,OAAO;QACL,QAAQ;QACR,IAAI,WAAW;YACb,IAAI,UAAU,KAAK,SAAS;gBAAE,OAAO,EAAE,CAAC;YACxC,gBAAgB,KAAK,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YACjD,OAAO,gBAAgB,CAAC;QAC1B,CAAC;QACD,IAAI,WAAW;YACb,IAAI,UAAU,KAAK,SAAS;gBAAE,OAAO,EAAE,CAAC;YACxC,gBAAgB,KAAK,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YACjD,OAAO,gBAAgB,CAAC;QAC1B,CAAC;QACD,IAAI,MAAM;YACR,OAAO,sBAAsB,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;QACxD,CAAC;QACD,IAAI,MAAM;YACR,OAAO,sBAAsB,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;QACxD,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,YAAY,CAAC,MAAmB;IACvC,IAAI,OAAO,MAAM,KAAK,UAAU;QAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAClD,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1B,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAuB,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,iBAAiB,CAAC,MAAmB;IAC5C,OAAO,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,QAAQ,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,YAAY,CACnB,MAA+B,EAC/B,KAAe,EACf,cAAyB,SAAS;IAElC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IACvD,IAAI,iBAAiB,CAAC,MAAM,CAAC,IAAI,MAAM,KAAK,MAAM;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAE5E,MAAM,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IACtC,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;YACf,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACjB,KAAK,MAAM,OAAO,IAAI,QAAQ;gBAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QAChD,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,KAAK,UAAU,SAAS,CAAC,MAAgB,EAAE,MAAmB;IAC5D,MAAM,EAAE,GAAG,QAAQ,CAAC,eAAe,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC5E,IAAI,CAAC;QACH,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,EAAE;YAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;YAAS,CAAC;QACT,EAAE,CAAC,KAAK,EAAE,CAAC;IACb,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,cAAc,CACrB,KAAsB,EACtB,MAAuB,EACvB,OAAsB;IAEtB,IAAI,OAAO,CAAC,MAAM,IAAI,MAAM;QAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,UAAU,CAAC,IAAkB,EAAE,KAAqC;IAC3E,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,WAAW,CAAC,IAAkB;IACrC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAC3B,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,SAAS,CAAC,OAAe,EAAE,IAAc,EAAE,MAAkB;IACpE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC;IAC9C,OAAO,IAAI,KAAK,CACd,GAAG,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAChG,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,gBAAgB,CACvB,MAAiC,EACjC,cAAyB,SAAS;IAElC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IAC7C,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CAAC,MAA0C;IAC9D,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC9D,OAAO,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACvE,CAAC;AAED;;;GAGG;AACH,SAAS,uBAAuB,CAAC,MAAc;IAC7C,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACxE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,KAAK,CAAC,GAAG,IAA4B;IACzD,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,EAAE,EAAE,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,SAAS,EAAE,GAAG,OAAO,CAAC;IACrE,MAAM,WAAW,GAAa,EAAE,CAAC;IACjC,MAAM,WAAW,GAAa,EAAE,CAAC;IACjC,MAAM,aAAa,GAAG,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACxD,MAAM,aAAa,GAAG,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACxD,MAAM,SAAS,GAAc,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,SAAS,CAAC,CAAC;IAEvF,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE;QAC3C,GAAG,SAAS;QACZ,KAAK,EAAE,CAAC,SAAS,EAAE,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,IAAI,CAAC;KAC3D,CAAC,CAAC;IAEH,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAExB,MAAM,KAAK,GAAoB,EAAE,CAAC;IAClC,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAClD,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAElD,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,CAAC;QACnC,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAChC,MAAM,GAAG,CAAC;IACZ,CAAC;IAED,MAAM,MAAM,GAAG,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;IAC1E,IAAI,KAAK,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC;QAAE,MAAM,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IAClF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,SAAS,CAAC,GAAG,IAAgC;IAC3D,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,EAAE,EAAE,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,SAAS,EAAE,GAAG,OAAO,CAAC;IACrE,MAAM,SAAS,GAAc,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,SAAS,CAAC,CAAC;IACvF,MAAM,aAAa,GAAG,MAAM,KAAK,SAAS,CAAC;IAC3C,MAAM,aAAa,GAAG,MAAM,KAAK,SAAS,CAAC;IAC3C,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC5C,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAE5C,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,EAAE,WAAW,EAAE;QACjD,GAAG,SAAS;QACZ,QAAQ,EAAE,aAAa,IAAI,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;QAC7D,KAAK,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,UAAU,CAAC;QAC1C,KAAK,EAAE,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS;KACrD,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IACpC,MAAM,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,MAAM,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,MAAM,UAAU,GAAG,oBAAoB,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;IAEhF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,IAAI,KAAK,IAAI,UAAU,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;YACvC,MAAM,GAAG,GAAG,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;YACxD,GAAG,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;YACzB,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IAED,IAAI,KAAK,IAAI,UAAU,CAAC,QAAQ,KAAK,CAAC;QAAE,MAAM,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;IAC1F,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,KAAK,CAAC,OAAe;IACnC,MAAM,IAAI,GAAa,EAAE,CAAC;IAE1B,IAAI,OAAO,GAAG,EAAE,CAAC;IACjB,IAAI,KAA4B,CAAC;IACjC,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,IAAI,MAAM,GAAG,KAAK,CAAC;IAEnB,MAAM,IAAI,GAAG,GAAG,EAAE;QAChB,IAAI,MAAM,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACjC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,CAAC;QACD,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,GAAG,KAAK,CAAC;IACjB,CAAC,CAAC;IAEF,KAAK,MAAM,EAAE,IAAI,OAAO,EAAE,CAAC;QACzB,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,IAAI,EAAE,CAAC;YACd,OAAO,GAAG,KAAK,CAAC;YAChB,SAAS;QACX,CAAC;QAED,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC;YAChB,OAAO,GAAG,IAAI,CAAC;YACf,SAAS;QACX,CAAC;QAED,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,EAAE,KAAK,KAAK,EAAE,CAAC;gBACjB,KAAK,GAAG,SAAS,CAAC;gBAClB,MAAM,GAAG,IAAI,CAAC;YAChB,CAAC;iBAAM,CAAC;gBACN,OAAO,IAAI,EAAE,CAAC;YAChB,CAAC;YACD,SAAS;QACX,CAAC;QAED,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;YAC7B,KAAK,GAAG,EAAE,CAAC;YACX,MAAM,GAAG,IAAI,CAAC;YACd,SAAS;QACX,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;YAClB,IAAI,EAAE,CAAC;YACP,SAAS;QACX,CAAC;QAED,OAAO,IAAI,EAAE,CAAC;IAChB,CAAC;IAED,+CAA+C;IAC/C,IAAI,KAAK,EAAE,CAAC;QACV,OAAO,CAAC,OAAO,CAAC,CAAC;IACnB,CAAC;IAED,iCAAiC;IACjC,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,IAAI,IAAI,CAAC;IAClB,CAAC;IAED,IAAI,EAAE,CAAC;IAEP,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AACxC,CAAC","sourcesContent":["/**\n * Portable subprocess helper built on `child_process.spawn` and line streaming.\n *\n * Ported from `dbx-tools-js/packages/cli/src/exec.ts`. Each stdio fd defaults to\n * `\"inherit\"`. {@link spawn} streams output line-by-line into {@link ExecResult.stdoutLines}\n * / {@link ExecResult.stderrLines}; its `stdout` / `stderr` getters join those lines.\n * {@link spawnSync} keeps the captured string; its `stdout` / `stderr` getters read\n * that string directly (line arrays split lazily on read).\n * Omitted `trim` (default) applies adaptive normalization: {@link spawnSync} drops\n * at most one trailing empty line / newline `spawnSync` adds; {@link spawn} does\n * not (readline never emits that extra line). `trim: true` strips all leading/\n * trailing whitespace in both modes; `trim: false` leaves output unchanged.\n *\n * @example Capture command output\n * ```ts\n * const { stdout } = await exec(\"git\", [\"rev-parse\", \"--show-toplevel\"], {\n *   stdout: \"capture\",\n *   stderr: \"ignore\",\n *   stdin: \"ignore\",\n * });\n * ```\n *\n * @example Stream and capture together\n * ```ts\n * await exec(\"pnpm\", [\"install\"], {\n *   stdout: [(line) => console.log(line), \"capture\"],\n *   check: true,\n * });\n * ```\n *\n * @example Synchronous capture (no line callbacks)\n * ```ts\n * const { stdout } = execSync(\"git\", [\"rev-parse\", \"--show-toplevel\"], {\n *   stdout: \"capture\",\n *   stderr: \"ignore\",\n *   stdin: \"ignore\",\n * });\n * ```\n *\n * @module\n */\nimport {\n  type ChildProcess,\n  type SpawnOptions,\n  spawn as nodeSpawn,\n  spawnSync as nodeSpawnSync,\n} from \"node:child_process\";\nimport * as readline from \"node:readline\";\nimport { Readable } from \"node:stream\";\n\n/** Stdio mode for a subprocess fd. */\nexport type ExecStdio = \"inherit\" | \"pipe\" | \"ignore\";\n\n/** Invoked once per output line when a fd is piped. */\nexport type LineHandler = (line: string) => void;\n\n/**\n * Stdio config for one fd.\n *\n * - `\"inherit\"` / `\"pipe\"` / `\"ignore\"` — pass through to `spawn`\n * - `\"capture\"` — pipe the fd and append each line to the result\n * - {@link LineHandler} — pipe and invoke the handler per line (lines are still captured)\n * - `(LineHandler | \"capture\")[]` — pipe; `\"capture\"` is a no-op marker, handlers run per line\n */\nexport type StdioOption = ExecStdio | LineHandler | \"capture\" | (LineHandler | \"capture\")[];\n\n/** Outcome of {@link spawn} / {@link spawnSync}: exit code, captured output, and line views. */\nexport type ExecResult = {\n  exitCode: number;\n  /**\n   * Captured stdout lines. For {@link spawn} these are built while the process runs;\n   * for {@link spawnSync} they are split from the captured string on first read.\n   */\n  readonly stdoutLines: string[];\n  /**\n   * Captured stderr lines. For {@link spawn} these are built while the process runs;\n   * for {@link spawnSync} they are split from the captured string on first read.\n   */\n  readonly stderrLines: string[];\n  /**\n   * Captured stdout text. {@link spawnSync} reads the captured string;\n   * {@link spawn} joins {@link stdoutLines}. See `trim` for normalization.\n   */\n  readonly stdout: string;\n  /**\n   * Captured stderr text. {@link spawnSync} reads the captured string;\n   * {@link spawn} joins {@link stderrLines}. See `trim` for normalization.\n   */\n  readonly stderr: string;\n};\n\n/** Options for {@link spawn}. Extends `SpawnOptions` except `stdio`, which is driven by `stdin` / `stdout` / `stderr`. */\nexport type ExecOptions = Omit<SpawnOptions, \"stdio\"> & {\n  /** `\"inherit\"` by default, or a string written to the process stdin. */\n  stdin?: ExecStdio | string;\n  stdout?: StdioOption;\n  stderr?: StdioOption;\n  /** Throw when the process exits with a non-zero code. */\n  check?: boolean;\n  /**\n   * Omitted — adaptive trim ({@link spawnSync} drops one spawn trailing newline,\n   * {@link spawn} does not); `true` — strip all leading/trailing whitespace;\n   * `false` — leave captured output unchanged.\n   */\n  trim?: boolean;\n};\n\n/** Stdio mode for {@link spawnSync} (no per-line callbacks). */\nexport type SyncExecStdio = ExecStdio | \"capture\";\n\n/** Options for {@link spawnSync}. Same shape as {@link ExecOptions} but without line-handler stdio. */\nexport type SyncExecOptions = Omit<SpawnOptions, \"stdio\"> & {\n  /** `\"inherit\"` by default, or a string written to the process stdin. */\n  stdin?: ExecStdio | string;\n  stdout?: SyncExecStdio;\n  stderr?: SyncExecStdio;\n  /** Throw when the process exits with a non-zero code. */\n  check?: boolean;\n  /**\n   * Omitted — adaptive trim ({@link spawnSync} drops one spawn trailing newline,\n   * {@link spawn} does not); `true` — strip all leading/trailing whitespace;\n   * `false` — leave captured output unchanged.\n   */\n  trim?: boolean;\n};\n\n/**\n * Spawn stdio mode plus an optional per-line callback after {@link resolveStdio}\n * maps a {@link StdioOption} into something `spawn` can consume.\n */\ntype ResolvedStdio = {\n  /** Value passed to `spawn`'s `stdio` tuple for this fd. */\n  mode: ExecStdio;\n  /** When set, each output line is appended to the capture buffer and forwarded here. */\n  onLine?: LineHandler;\n};\n\nexport type SpawnArgs<T extends SpawnOptions> =\n  | [command: string, ...args: string[]]\n  | [command: string, args: readonly string[]]\n  | [command: string, args: readonly string[], options: T]\n  | [command: string, ...argsAndOptions: [...string[], T]];\n\ninterface ParsedSpawnArgs<T extends SpawnOptions> {\n  command: string;\n  commandArgs: string[];\n  options?: T;\n}\n\nfunction parseSpawnArgs<T extends SpawnOptions>(input: SpawnArgs<T>): ParsedSpawnArgs<T> {\n  let [value, ...values] = input;\n  const [command, ...commandArgs] = shlex(value);\n  if (commandArgs.length == 1 && values.length === 0) {\n    return {\n      command,\n      commandArgs: [],\n    };\n  }\n\n  const last = values.at(-1);\n  const options =\n    last !== null && typeof last === \"object\" && !Array.isArray(last) ? last : undefined;\n  const argumentValues = options ? values.slice(0, -1) : values;\n  const valueArgs: string[] =\n    argumentValues.length === 1 && Array.isArray(argumentValues[0])\n      ? [...argumentValues[0]]\n      : argumentValues;\n\n  return {\n    command,\n    commandArgs: [...commandArgs, ...valueArgs],\n    options: options as T,\n  };\n}\n\n/**\n * Drop the single trailing empty entry `spawnSync` adds when splitting on a final\n * newline (`\"hi\\n\"` -> `[\"hi\", \"\"]`). Does not remove multiple trailing empties.\n */\nfunction withoutSpawnTrailingEmptyLine(lines: readonly string[]): string[] {\n  if (lines.length > 0 && lines[lines.length - 1] === \"\") {\n    return lines.slice(0, -1);\n  }\n  return lines as string[];\n}\n\n/** Remove at most one trailing newline from captured spawn stdout/stderr text. */\nfunction trimSingleTrailingNewline(text: string): string {\n  if (text.endsWith(\"\\r\\n\")) return text.slice(0, -2);\n  if (text.endsWith(\"\\n\")) return text.slice(0, -1);\n  return text;\n}\n\n/** Line-array view of async-captured output. */\nfunction normalizedAsyncLines(lines: readonly string[], trim: boolean | undefined): string[] {\n  if (trim === true) return linesFromCapturedOutput(lines.join(\"\\n\").trim());\n  return lines as string[];\n}\n\n/** Join async-captured lines into stdout/stderr text. */\nfunction formatAsyncCapturedLines(lines: readonly string[], trim: boolean | undefined): string {\n  const joined = lines.join(\"\\n\");\n  return trim === true ? joined.trim() : joined;\n}\n\n/** Line-array view of sync-captured output. */\nfunction normalizedSyncLines(lines: readonly string[], trim: boolean | undefined): string[] {\n  if (trim === false) return lines as string[];\n  if (trim === true) return linesFromCapturedOutput(lines.join(\"\\n\").trim());\n  return withoutSpawnTrailingEmptyLine(lines);\n}\n\n/** Format sync-captured stdout/stderr text. */\nfunction formatSyncCapturedText(\n  text: string | undefined,\n  trim: boolean | undefined,\n): string | undefined {\n  if (text === undefined) return undefined;\n  if (trim === false) return text;\n  if (trim === true) return text.trim();\n  return trimSingleTrailingNewline(text);\n}\n\n/**\n * Human-readable label for a spawned command, used in error messages.\n *\n * @param command - Executable name or path\n * @param args - Arguments passed to the executable\n * @returns Backtick-wrapped `command arg1 arg2 ...` string\n */\nfunction commandLabel(command: string, args: string[]): string {\n  return `\\`${command} ${args.join(\" \")}\\``;\n}\n\n/**\n * Build the object returned from {@link spawn} with live line arrays and lazy\n * trimmed `stdout` / `stderr` getters derived from those lines.\n */\nfunction createExecResult(\n  exitCode: number,\n  stdoutLines: string[],\n  stderrLines: string[],\n  trim: boolean | undefined,\n): ExecResult {\n  return {\n    exitCode,\n    get stdoutLines() {\n      return normalizedAsyncLines(stdoutLines, trim);\n    },\n    get stderrLines() {\n      return normalizedAsyncLines(stderrLines, trim);\n    },\n    get stdout() {\n      return formatAsyncCapturedLines(stdoutLines, trim);\n    },\n    get stderr() {\n      return formatAsyncCapturedLines(stderrLines, trim);\n    },\n  };\n}\n\n/**\n * Build the object returned from {@link spawnSync}. Captured strings are stored\n * as-is; `stdout` / `stderr` trim directly, and line arrays split only on read.\n */\nfunction createSyncExecResult(\n  exitCode: number,\n  stdoutText: string | undefined,\n  stderrText: string | undefined,\n  trim: boolean | undefined,\n): ExecResult {\n  let stdoutLinesCache: string[] | undefined;\n  let stderrLinesCache: string[] | undefined;\n\n  const syncLines = (text: string | undefined): string[] | undefined => {\n    if (text === undefined) return undefined;\n    return normalizedSyncLines(linesFromCapturedOutput(text), trim);\n  };\n\n  return {\n    exitCode,\n    get stdoutLines() {\n      if (stdoutText === undefined) return [];\n      stdoutLinesCache ??= syncLines(stdoutText) ?? [];\n      return stdoutLinesCache;\n    },\n    get stderrLines() {\n      if (stderrText === undefined) return [];\n      stderrLinesCache ??= syncLines(stderrText) ?? [];\n      return stderrLinesCache;\n    },\n    get stdout() {\n      return formatSyncCapturedText(stdoutText, trim) ?? \"\";\n    },\n    get stderr() {\n      return formatSyncCapturedText(stderrText, trim) ?? \"\";\n    },\n  };\n}\n\n/**\n * Extract user-supplied line handlers from a {@link StdioOption}.\n *\n * The `\"capture\"` marker is filtered out; capture itself is always handled by\n * pushing into the line buffer inside {@link resolveStdio}.\n *\n * @param option - Stdio option that may embed one or more handlers\n * @returns Handlers to invoke after each captured line (may be empty)\n */\nfunction lineHandlers(option: StdioOption): LineHandler[] {\n  if (typeof option === \"function\") return [option];\n  if (Array.isArray(option)) {\n    return option.filter((item): item is LineHandler => item !== \"capture\");\n  }\n  return [];\n}\n\n/**\n * True when a stdio option is a string spawn mode rather than capture/handlers.\n *\n * {@link resolveStdio} still treats `\"pipe\"` as pipe-and-capture; only\n * `\"inherit\"` and `\"ignore\"` return without a line callback.\n *\n * @param option - Stdio option to classify\n * @returns Whether `option` is `\"inherit\"`, `\"pipe\"`, or `\"ignore\"`\n */\nfunction isPassthroughMode(option: StdioOption): option is ExecStdio {\n  return option === \"inherit\" || option === \"pipe\" || option === \"ignore\";\n}\n\n/**\n * Map a {@link StdioOption} into a spawn stdio mode and optional line callback.\n *\n * Piped modes (`\"capture\"`, `\"pipe\"`, handlers, arrays) append every line to\n * `lines` and invoke any embedded handlers. Omitted options use `defaultMode`.\n *\n * @param option - Caller stdio preference for one fd\n * @param lines - Mutable buffer that receives each piped line\n * @param defaultMode - Spawn mode when `option` is omitted (`\"inherit\"` by default)\n * @returns Resolved spawn mode and optional per-line callback\n */\nfunction resolveStdio(\n  option: StdioOption | undefined,\n  lines: string[],\n  defaultMode: ExecStdio = \"inherit\",\n): ResolvedStdio {\n  if (option === undefined) return { mode: defaultMode };\n  if (isPassthroughMode(option) && option !== \"pipe\") return { mode: option };\n\n  const handlers = lineHandlers(option);\n  return {\n    mode: \"pipe\",\n    onLine: (line) => {\n      lines.push(line);\n      for (const handler of handlers) handler(line);\n    },\n  };\n}\n\n/**\n * Read a readable stream line-by-line and invoke `onLine` for each chunk.\n *\n * Uses `readline` so `\\r\\n` and bare `\\n` are normalized. The interface is\n * always closed in a `finally` block.\n *\n * @param stream - Subprocess stdout or stderr stream\n * @param onLine - Callback invoked once per output line\n */\nasync function readLines(stream: Readable, onLine: LineHandler): Promise<void> {\n  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });\n  try {\n    for await (const line of rl) onLine(line);\n  } finally {\n    rl.close();\n  }\n}\n\n/**\n * Start a background line read when the resolved handler pipes a stream.\n *\n * @param reads - Promise list awaited before returning the {@link ExecResult}\n * @param stream - Subprocess stream for this fd (`null` when unavailable)\n * @param handler - Resolved stdio config from {@link resolveStdio}\n */\nfunction queueLineReads(\n  reads: Promise<void>[],\n  stream: Readable | null,\n  handler: ResolvedStdio,\n): void {\n  if (handler.onLine && stream) reads.push(readLines(stream, handler.onLine));\n}\n\n/**\n * Write string stdin to a spawned process and close the stream.\n *\n * No-op unless `stdin` is a string and `proc.stdin` is available.\n *\n * @param proc - Child process returned from `spawn`\n * @param stdin - Stdio mode or string payload from {@link ExecOptions}\n */\nfunction writeStdin(proc: ChildProcess, stdin: ExecStdio | string | undefined): void {\n  if (typeof stdin === \"string\" && proc.stdin) {\n    proc.stdin.write(stdin);\n    proc.stdin.end();\n  }\n}\n\n/**\n * Await process exit and normalize a missing exit code to `1`.\n *\n * Rejects when spawn fails before `close` (e.g. executable not found).\n *\n * @param proc - Child process returned from `spawn`\n * @returns Resolved exit code\n */\nfunction waitForExit(proc: ChildProcess): Promise<number> {\n  return new Promise((resolve, reject) => {\n    proc.once(\"error\", reject);\n    proc.once(\"close\", (code) => resolve(code ?? 1));\n  });\n}\n\n/**\n * Build an `Error` for a non-zero exit when {@link ExecOptions.check} is set.\n *\n * Prefers trimmed stderr text, then stdout, in the message body.\n *\n * @param command - Executable name or path\n * @param args - Arguments passed to the executable\n * @param result - Completed exec outcome with captured output\n * @returns Error suitable for throwing from {@link spawn}\n */\nfunction execError(command: string, args: string[], result: ExecResult): Error {\n  const detail = result.stderr || result.stdout;\n  return new Error(\n    `${commandLabel(command, args)} failed (exit ${result.exitCode})${detail ? `: ${detail}` : \"\"}`,\n  );\n}\n\n/**\n * Map a {@link SyncExecStdio} option to a `spawnSync` stdio mode.\n *\n * `\"capture\"` pipes the fd so output can be read into the {@link ExecResult}.\n *\n * @param option - Caller stdio preference for one fd\n * @param defaultMode - Spawn mode when `option` is omitted (`\"inherit\"` by default)\n * @returns Value for the `spawnSync` stdio tuple\n */\nfunction resolveSyncStdio(\n  option: SyncExecStdio | undefined,\n  defaultMode: ExecStdio = \"inherit\",\n): ExecStdio {\n  if (option === undefined) return defaultMode;\n  if (option === \"capture\") return \"pipe\";\n  return option;\n}\n\n/**\n * Normalize raw `spawnSync` output to a UTF-8 string when capture is enabled.\n */\nfunction capturedText(output: string | Buffer | null | undefined): string | undefined {\n  if (output === null || output === undefined) return undefined;\n  return typeof output === \"string\" ? output : output.toString(\"utf8\");\n}\n\n/**\n * Split captured process output into lines for {@link ExecResult.stdoutLines} /\n * {@link ExecResult.stderrLines} ({@link spawnSync} only; invoked lazily).\n */\nfunction linesFromCapturedOutput(output: string): string[] {\n  return output.replace(/\\r\\n/g, \"\\n\").replace(/\\r/g, \"\\n\").split(\"\\n\");\n}\n\n/**\n * Spawn a subprocess and wait for exit.\n *\n * @param command - Executable to run (resolved on `PATH` when `shell` is set on options)\n * @param args - Arguments passed verbatim to the executable\n * @param options - Spawn, stdio, and check options\n * @returns Exit code, captured line arrays, and trimmed `stdout` / `stderr` getters\n * @throws When spawn fails, line reads fail, or `check` is true and exit code is non-zero\n */\nexport async function spawn(...args: SpawnArgs<ExecOptions>): Promise<ExecResult> {\n  const { command, commandArgs, options = {} } = parseSpawnArgs(args);\n  const { stdin, stdout, stderr, check, trim, ...spawnOpts } = options;\n  const stdoutLines: string[] = [];\n  const stderrLines: string[] = [];\n  const stdoutHandler = resolveStdio(stdout, stdoutLines);\n  const stderrHandler = resolveStdio(stderr, stderrLines);\n  const stdinMode: ExecStdio = typeof stdin === \"string\" ? \"pipe\" : (stdin ?? \"inherit\");\n\n  const proc = nodeSpawn(command, commandArgs, {\n    ...spawnOpts,\n    stdio: [stdinMode, stdoutHandler.mode, stderrHandler.mode],\n  });\n\n  writeStdin(proc, stdin);\n\n  const reads: Promise<void>[] = [];\n  queueLineReads(reads, proc.stdout, stdoutHandler);\n  queueLineReads(reads, proc.stderr, stderrHandler);\n\n  let exitCode = 1;\n  try {\n    exitCode = await waitForExit(proc);\n    await Promise.all(reads);\n  } catch (err) {\n    await Promise.allSettled(reads);\n    throw err;\n  }\n\n  const result = createExecResult(exitCode, stdoutLines, stderrLines, trim);\n  if (check && result.exitCode !== 0) throw execError(command, commandArgs, result);\n  return result;\n}\n\n/**\n * Spawn a subprocess synchronously and wait for exit.\n *\n * Unlike {@link spawn}, stdio options are limited to `\"inherit\"`, `\"pipe\"`,\n * `\"ignore\"`, and `\"capture\"` — no per-line callbacks.\n *\n * @param command - Executable to run (resolved on `PATH` when `shell` is set on options)\n * @param args - Arguments passed verbatim to the executable\n * @param spawnSync - Spawn, stdio, and check options\n * @returns Exit code, captured line arrays, and trimmed `stdout` / `stderr` getters\n * @throws When spawn fails or `check` is true and exit code is non-zero\n */\nexport function spawnSync(...args: SpawnArgs<SyncExecOptions>): ExecResult {\n  const { command, commandArgs, options = {} } = parseSpawnArgs(args);\n  const { stdin, stdout, stderr, check, trim, ...spawnOpts } = options;\n  const stdinMode: ExecStdio = typeof stdin === \"string\" ? \"pipe\" : (stdin ?? \"inherit\");\n  const captureStdout = stdout === \"capture\";\n  const captureStderr = stderr === \"capture\";\n  const stdoutMode = resolveSyncStdio(stdout);\n  const stderrMode = resolveSyncStdio(stderr);\n\n  const result = nodeSpawnSync(command, commandArgs, {\n    ...spawnOpts,\n    encoding: captureStdout || captureStderr ? \"utf8\" : undefined,\n    stdio: [stdinMode, stdoutMode, stderrMode],\n    input: typeof stdin === \"string\" ? stdin : undefined,\n  });\n\n  const exitCode = result.status ?? 1;\n  const stdoutText = captureStdout ? capturedText(result.stdout) : undefined;\n  const stderrText = captureStderr ? capturedText(result.stderr) : undefined;\n  const execResult = createSyncExecResult(exitCode, stdoutText, stderrText, trim);\n\n  if (result.error) {\n    if (check || execResult.exitCode !== 0) {\n      const err = execError(command, commandArgs, execResult);\n      err.cause = result.error;\n      throw err;\n    }\n  }\n\n  if (check && execResult.exitCode !== 0) throw execError(command, commandArgs, execResult);\n  return execResult;\n}\n\n/**\n * Splits a shell-like command into argv.\n *\n * Supports:\n *   - whitespace separators\n *   - single and double quotes\n *   - backslash escaping\n *   - escaped spaces\n *   - empty quoted strings\n *\n * If the input is malformed (for example, an unterminated quote),\n * returns the original string as a single argument.\n */\nexport function shlex(command: string): string[] {\n  const args: string[] = [];\n\n  let current = \"\";\n  let quote: \"'\" | '\"' | undefined;\n  let escaped = false;\n  let quoted = false;\n\n  const push = () => {\n    if (quoted || current.length > 0) {\n      args.push(current);\n    }\n    current = \"\";\n    quoted = false;\n  };\n\n  for (const ch of command) {\n    if (escaped) {\n      current += ch;\n      escaped = false;\n      continue;\n    }\n\n    if (ch === \"\\\\\") {\n      escaped = true;\n      continue;\n    }\n\n    if (quote) {\n      if (ch === quote) {\n        quote = undefined;\n        quoted = true;\n      } else {\n        current += ch;\n      }\n      continue;\n    }\n\n    if (ch === \"'\" || ch === '\"') {\n      quote = ch;\n      quoted = true;\n      continue;\n    }\n\n    if (/\\s/.test(ch)) {\n      push();\n      continue;\n    }\n\n    current += ch;\n  }\n\n  // Malformed input: treat as a literal command.\n  if (quote) {\n    return [command];\n  }\n\n  // Trailing backslash is literal.\n  if (escaped) {\n    current += \"\\\\\";\n  }\n\n  push();\n\n  return args.length ? args : [command];\n}\n"]}

package/lib/src/file.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Filesystem utilities: best-effort `fs.stat` helpers that never throw.
+ *
+ * @module
+ */
+import { Stats } from "node:fs";
+/**
+ * Best-effort `fs.stat` (sync). Returns `undefined` for a blank path or when the
+ * path can't be stat'd (missing, permission denied, ...), so callers can treat
+ * "not there" and "not accessible" the same and never handle an exception.
+ */
+export declare function statSync(path: string): Stats | undefined;

package/lib/src/file.js

@@ -0,0 +1,21 @@
+/**
+ * Filesystem utilities: best-effort `fs.stat` helpers that never throw.
+ *
+ * @module
+ */
+import { statSync as nodeStatSync } from "node:fs";
+/**
+ * Best-effort `fs.stat` (sync). Returns `undefined` for a blank path or when the
+ * path can't be stat'd (missing, permission denied, ...), so callers can treat
+ * "not there" and "not accessible" the same and never handle an exception.
+ */
+export function statSync(path) {
+    if (path) {
+        try {
+            return nodeStatSync(path);
+        }
+        catch { }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxPQUFPLEVBQVMsUUFBUSxJQUFJLFlBQVksRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUUxRDs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLFFBQVEsQ0FBQyxJQUFZO0lBQ25DLElBQUksSUFBSSxFQUFFLENBQUM7UUFDVCxJQUFJLENBQUM7WUFDSCxPQUFPLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUM1QixDQUFDO1FBQUMsTUFBTSxDQUFDLENBQUEsQ0FBQztJQUNaLENBQUM7SUFDRCxPQUFPLFNBQVMsQ0FBQztBQUNuQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBGaWxlc3lzdGVtIHV0aWxpdGllczogYmVzdC1lZmZvcnQgYGZzLnN0YXRgIGhlbHBlcnMgdGhhdCBuZXZlciB0aHJvdy5cbiAqXG4gKiBAbW9kdWxlXG4gKi9cbmltcG9ydCB7IFN0YXRzLCBzdGF0U3luYyBhcyBub2RlU3RhdFN5bmMgfSBmcm9tIFwibm9kZTpmc1wiO1xuXG4vKipcbiAqIEJlc3QtZWZmb3J0IGBmcy5zdGF0YCAoc3luYykuIFJldHVybnMgYHVuZGVmaW5lZGAgZm9yIGEgYmxhbmsgcGF0aCBvciB3aGVuIHRoZVxuICogcGF0aCBjYW4ndCBiZSBzdGF0J2QgKG1pc3NpbmcsIHBlcm1pc3Npb24gZGVuaWVkLCAuLi4pLCBzbyBjYWxsZXJzIGNhbiB0cmVhdFxuICogXCJub3QgdGhlcmVcIiBhbmQgXCJub3QgYWNjZXNzaWJsZVwiIHRoZSBzYW1lIGFuZCBuZXZlciBoYW5kbGUgYW4gZXhjZXB0aW9uLlxuICovXG5leHBvcnQgZnVuY3Rpb24gc3RhdFN5bmMocGF0aDogc3RyaW5nKTogU3RhdHMgfCB1bmRlZmluZWQge1xuICBpZiAocGF0aCkge1xuICAgIHRyeSB7XG4gICAgICByZXR1cm4gbm9kZVN0YXRTeW5jKHBhdGgpO1xuICAgIH0gY2F0Y2gge31cbiAgfVxuICByZXR1cm4gdW5kZWZpbmVkO1xufVxuIl19

package/lib/src/project.d.ts

@@ -0,0 +1,54 @@
+import { Stats } from "node:fs";
+import { net } from "@dbx-tools/shared-core";
+/** A command's stdout, classified as a filesystem path and/or a URL. */
+export interface ProjectContext {
+    readonly cwd: string;
+    readonly output: string;
+    /** `output` when it names something on disk. */
+    readonly path?: string;
+    /** `fs.stat` of {@link path}, when it exists. */
+    readonly pathStats?: Stats;
+    /**
+     * `output` parsed into a chainable {@link net.UrlBuilder}, when it is a real
+     * network URL - a non-blank scheme (not `file:`) AND a non-blank hostname.
+     * Bare paths, scp-like `git@host:...` remotes, and `file:` URLs stay unset.
+     */
+    readonly url?: net.UrlBuilder;
+}
+export declare function root(cwd?: string): string | undefined;
+/**
+ * Parse a git remote URL (`https://...`, `git@host:owner/repo.git`, etc.) and
+ * return the repo segment, stripping any `.git` suffix. Returns `undefined` for
+ * empty or unparsable input.
+ */
+export declare function parseGitRemote(url: string): string | undefined;
+/**
+ * Yield candidate project-root directories for `cwd`, in priority order: the
+ * `npm prefix`, the git top-level, then `cwd` itself. Duplicates are skipped;
+ * only existing directories are yielded (except the final `cwd` fallback).
+ */
+export declare function resolveProjectRoots(cwd?: string): Generator<string>;
+/**
+ * Resolve a human-friendly project name for the repo rooted at `cwd`:
+ * `package.json` `name`, then the git remote's repo name, then the root
+ * directory's basename.
+ */
+export declare function name(cwd?: string): string;
+/**
+ * The repo's canonical remote URL, or `undefined` when there is no git remote.
+ * Tries `gh repo view` first (host-accurate, no parsing), then normalizes
+ * `git remote get-url origin`. Both underlying commands are cached per `cwd` via
+ * {@link projectContextCommand}.
+ *
+ * @param cwd - directory to resolve from (defaults to `process.cwd()`).
+ * @param format - `"https"` (default) yields `https://host/owner/repo`;
+ *   `"npm"` yields npm's `git+https://host/owner/repo.git` form (for a
+ *   `package.json` `repository.url` that passes npm provenance).
+ */
+export declare function repositoryUrl(cwd?: string, format?: "https" | "npm"): string | undefined;
+/**
+ * The active npm registry (`npm config get registry`) as a chainable
+ * {@link net.UrlBuilder}, or `undefined` when npm is absent or prints no URL.
+ * Cached per `cwd` via {@link projectContextCommand}.
+ */
+export declare function npmRegistry(cwd?: string): net.UrlBuilder | undefined;