runwork 0.15.0 → 0.15.2

package/dist/utils/http.js

@@ -1,421 +0,0 @@
-/**
- * Minimal `fetch`-like HTTP client built on `node:http` / `node:https`.
- *
- * Why this exists rather than calling `fetch` directly:
- *  1) Single seam for diagnostics, retries, transport swaps, etc., without
- *     touching every call site.
- *  2) Opt-in `curl` transport (set `RUNWORK_HTTP_TRANSPORT=curl`) as a
- *     break-glass: it shells out to the system `curl` binary so HTTP runs
- *     in a subprocess, immune to any runtime regression in the Bun-compiled
- *     binary. We've kept it after needing it once on an older Bun version.
- *
- * Default transport is `node:https` on every platform. Surface mirrors
- * enough of the standard `Response` API for call sites to swap from
- * `fetch(...)` to `httpFetch(...)` with no other change. Out of scope:
- * streaming bodies, AbortController, ReadableStream request bodies, the
- * `cache` option. This is a workaround layer, not a fetch polyfill.
- */
-import { request as httpRequest } from 'node:http';
-import { request as httpsRequest } from 'node:https';
-import { URL } from 'node:url';
-import { spawn } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createBrotliDecompress, createGunzip, createInflate, createInflateRaw, } from 'node:zlib';
-const MAX_REDIRECTS = 10;
-let transportOverride = 'auto';
-export function __setTransportForTests(t) { transportOverride = t; }
-function pickTransport() {
-    if (transportOverride === 'curl')
-        return 'curl';
-    if (transportOverride === 'node')
-        return 'node';
-    const env = (process.env.RUNWORK_HTTP_TRANSPORT || '').toLowerCase().trim();
-    if (env === 'curl')
-        return 'curl';
-    return 'node';
-}
-export async function httpFetch(url, init = {}) {
-    const transport = pickTransport();
-    if (transport === 'curl')
-        return curlFetch(url, init);
-    return doRequest(url, init, 0);
-}
-async function doRequest(url, init, redirectCount) {
-    const parsed = new URL(url);
-    const isHttps = parsed.protocol === 'https:';
-    const isHttp = parsed.protocol === 'http:';
-    if (!isHttps && !isHttp) {
-        throw new Error(`Unsupported protocol "${parsed.protocol}" -- only http: and https: are supported.`);
-    }
-    const requestFn = isHttps ? httpsRequest : httpRequest;
-    const headers = normalizeHeaders(init.headers);
-    const method = (init.method || 'GET').toUpperCase();
-    const isBodylessMethod = method === 'GET' || method === 'HEAD';
-    const bodyBuffer = isBodylessMethod ? null : bodyToBuffer(init.body);
-    if (bodyBuffer && headers['content-length'] === undefined) {
-        headers['content-length'] = String(bodyBuffer.byteLength);
-    }
-    // Match `fetch`'s default of advertising compression support. We
-    // transparently decompress gzip/deflate/br responses below.
-    if (headers['accept-encoding'] === undefined) {
-        headers['accept-encoding'] = 'gzip, deflate, br';
-    }
-    const requestOptions = {
-        method,
-        headers,
-    };
-    return new Promise((resolve, reject) => {
-        const req = requestFn(url, requestOptions, (res) => {
-            const status = res.statusCode ?? 0;
-            // Follow redirects manually so behavior matches `fetch`. We wait for
-            // the previous response to fully drain before starting the recursive
-            // request: guarantees socket cleanup ordering and avoids leaking
-            // the previous request when the new one fails.
-            const location = res.headers.location;
-            if (status >= 300 && status < 400 && location && redirectCount < MAX_REDIRECTS) {
-                res.resume();
-                res.once('end', () => {
-                    let nextUrl;
-                    try {
-                        nextUrl = new URL(location, url).toString();
-                    }
-                    catch (err) {
-                        reject(err);
-                        return;
-                    }
-                    const shouldDowngradeToGet = status === 303 ||
-                        ((status === 301 || status === 302) && method !== 'GET' && method !== 'HEAD');
-                    const nextInit = shouldDowngradeToGet
-                        ? { ...init, method: 'GET', body: undefined }
-                        : init;
-                    doRequest(nextUrl, nextInit, redirectCount + 1).then(resolve, reject);
-                });
-                res.once('error', reject);
-                return;
-            }
-            // Decompress gzip / deflate / br transparently to match fetch.
-            const decoded = decompressedStream(res);
-            const chunks = [];
-            decoded.on('data', (chunk) => {
-                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-            });
-            decoded.on('end', () => {
-                const buffer = Buffer.concat(chunks);
-                // For HEAD responses there is no body; preserve the empty buffer.
-                resolve(buildResponse(url, res, status, buffer));
-            });
-            decoded.on('error', reject);
-            // Surface upstream socket errors too when we are reading through a
-            // decompressor (the transformed stream wouldn't otherwise see them).
-            if (decoded !== res) {
-                res.on('error', reject);
-            }
-        });
-        req.on('error', reject);
-        if (bodyBuffer)
-            req.write(bodyBuffer);
-        req.end();
-    });
-}
-function normalizeHeaders(input) {
-    const out = {};
-    if (!input)
-        return out;
-    if (input instanceof Headers) {
-        input.forEach((value, key) => {
-            out[key.toLowerCase()] = value;
-        });
-        return out;
-    }
-    for (const [key, value] of Object.entries(input)) {
-        if (value === undefined || value === null)
-            continue;
-        out[key.toLowerCase()] = String(value);
-    }
-    return out;
-}
-function bodyToBuffer(body) {
-    if (body === undefined || body === null)
-        return null;
-    if (typeof body === 'string')
-        return Buffer.from(body, 'utf-8');
-    if (Buffer.isBuffer(body))
-        return body;
-    if (body instanceof Uint8Array)
-        return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
-    if (body instanceof ArrayBuffer)
-        return Buffer.from(new Uint8Array(body));
-    throw new TypeError('Unsupported request body type');
-}
-function decompressedStream(res) {
-    // Per RFC 7230, Content-Encoding may be a comma-separated list of
-    // transformations applied in order. Unwrap them in reverse, but in
-    // practice servers send a single encoding so the simple cases dominate.
-    const raw = (res.headers['content-encoding'] || '').toString().toLowerCase().trim();
-    if (!raw || raw === 'identity')
-        return res;
-    const encodings = raw.split(',').map((s) => s.trim()).filter(Boolean).reverse();
-    let stream = res;
-    for (const enc of encodings) {
-        let decoder = null;
-        if (enc === 'gzip' || enc === 'x-gzip')
-            decoder = createGunzip();
-        else if (enc === 'br')
-            decoder = createBrotliDecompress();
-        else if (enc === 'deflate')
-            decoder = createInflate();
-        else if (enc === 'deflate-raw')
-            decoder = createInflateRaw();
-        else
-            continue; // unknown encoding -- pass bytes through
-        stream.pipe(decoder);
-        stream = decoder;
-    }
-    return stream;
-}
-function buildResponse(url, res, status, buffer) {
-    const headers = new Headers();
-    for (const [name, value] of Object.entries(res.headers)) {
-        if (value === undefined)
-            continue;
-        if (Array.isArray(value)) {
-            for (const v of value)
-                headers.append(name, v);
-        }
-        else {
-            headers.set(name, value);
-        }
-    }
-    return {
-        ok: status >= 200 && status < 300,
-        status,
-        statusText: res.statusMessage ?? '',
-        headers,
-        url,
-        async text() {
-            return buffer.toString('utf-8');
-        },
-        async json() {
-            const text = buffer.toString('utf-8');
-            return JSON.parse(text);
-        },
-        async arrayBuffer() {
-            // Slice the underlying buffer so the returned ArrayBuffer matches the
-            // exact byte range and is independent of Node's internal pool.
-            const copy = new Uint8Array(buffer.byteLength);
-            copy.set(buffer);
-            return copy.buffer;
-        },
-    };
-}
-// ────────────────────────────────────────────────────────────────────────
-// curl-based transport (Windows workaround)
-//
-// On Windows we spawn `curl.exe` for every HTTP call so we never touch
-// Bun's broken HTTP runtime in the standalone binary. The subprocess
-// approach trades a few tens of milliseconds of process-spawn overhead per
-// request for rock-solid reliability. Curl ships at
-// C:\Windows\System32\curl.exe on Windows 10+ since 2018.
-//
-// Layout:
-//   - body          → written by curl to a temp file (--output)
-//   - response hdrs → written by curl to a temp file (--dump-header)
-//   - status/url    → printed by curl to stdout via --write-out
-//
-// We never let body bytes share a stream with metadata, so binary
-// downloads (zip skeletons, presigned URL fetches) round-trip cleanly.
-// ────────────────────────────────────────────────────────────────────────
-async function curlFetch(url, init) {
-    return curlFetchOnce(url, init, 0);
-}
-async function curlFetchOnce(url, init, redirectCount) {
-    // Quick URL sanity check so we throw the same way the node:https path
-    // does for unsupported protocols, before paying the spawn cost.
-    const parsed = new URL(url);
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-        throw new Error(`Unsupported protocol "${parsed.protocol}" -- only http: and https: are supported.`);
-    }
-    const headers = normalizeHeaders(init.headers);
-    const method = (init.method || 'GET').toUpperCase();
-    const isBodyless = method === 'GET' || method === 'HEAD';
-    const bodyBuffer = isBodyless ? null : bodyToBuffer(init.body);
-    if (headers['accept-encoding'] === undefined) {
-        headers['accept-encoding'] = 'identity';
-    }
-    // Per-call temp directory keeps cleanup simple and concurrent calls from
-    // racing on shared filenames.
-    const tmp = mkdtempSync(join(tmpdir(), 'runwork-curl-'));
-    const bodyOutPath = join(tmp, 'body.bin');
-    const headerOutPath = join(tmp, 'headers.txt');
-    const args = [
-        '--silent',
-        '--show-error',
-        // We deliberately do NOT pass --location. curl's redirect-method
-        // semantics differ subtly from fetch's (notably curl can preserve
-        // POST across 303 in some versions despite the spec). We follow
-        // redirects ourselves below so behavior matches the node:https
-        // transport exactly.
-        '--output', bodyOutPath, // body to file (binary safe)
-        '--dump-header', headerOutPath, // response headers to file
-        '--write-out', '%{http_code}\n%{url_effective}\n',
-    ];
-    if (method === 'HEAD') {
-        // --head sends HEAD AND tells curl not to expect a body, otherwise
-        // curl hangs waiting for body bytes. The downside is that --head also
-        // writes the response headers into the --output body file -- we work
-        // around that below by ignoring the body buffer when method is HEAD.
-        args.push('--head');
-    }
-    else if (method !== 'GET') {
-        args.push('--request', method);
-    }
-    // Curl's default already follows fetch semantics on 301/302/303 (downgrade
-    // POST to GET). We do NOT pass --post30x because those flags violate that
-    // default and force POST to be preserved across redirects.
-    for (const [name, value] of Object.entries(headers)) {
-        args.push('--header', `${name}: ${value}`);
-    }
-    if (bodyBuffer) {
-        // Read request body from stdin so we don't have to write it to disk.
-        args.push('--data-binary', '@-');
-    }
-    args.push(url);
-    // Async spawn: spawnSync would block the event loop, which deadlocks
-    // unit tests (the test server lives in the same Node worker, can't
-    // service curl's connection while we're blocked). The async path is
-    // also strictly nicer for any future caller that wants to overlap
-    // requests.
-    const result = await new Promise((resolve) => {
-        const child = spawn('curl', args, { windowsHide: true });
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        child.stdout.on('data', (c) => stdoutChunks.push(c));
-        child.stderr.on('data', (c) => stderrChunks.push(c));
-        child.on('error', (err) => resolve({
-            status: -1,
-            stdout: Buffer.concat(stdoutChunks).toString('utf-8'),
-            stderr: Buffer.concat(stderrChunks).toString('utf-8'),
-            error: err,
-        }));
-        child.on('close', (code) => resolve({
-            status: code ?? -1,
-            stdout: Buffer.concat(stdoutChunks).toString('utf-8'),
-            stderr: Buffer.concat(stderrChunks).toString('utf-8'),
-        }));
-        if (bodyBuffer) {
-            child.stdin.write(bodyBuffer);
-        }
-        child.stdin.end();
-    });
-    if (result.error) {
-        safeRm(tmp);
-        throw result.error;
-    }
-    const stdoutLines = result.stdout.trim().split(/\r?\n/);
-    const statusLine = stdoutLines[0] || '0';
-    const finalUrl = stdoutLines[1] || url;
-    const status = Number.parseInt(statusLine, 10) || 0;
-    if (status === 0) {
-        // curl never received a response, or exited before writing the status.
-        const stderr = result.stderr.trim();
-        safeRm(tmp);
-        throw new Error(`curl failed (exit ${result.status}): ${stderr || 'no error output'}`);
-    }
-    let bodyBuf;
-    try {
-        bodyBuf = readFileSync(bodyOutPath);
-    }
-    catch {
-        bodyBuf = Buffer.alloc(0);
-    }
-    // For HEAD, --head causes curl to write the response status line + headers
-    // into the body output file (since there is no real body to write). Strip
-    // it so callers see an empty body, matching fetch's HEAD behavior.
-    if (method === 'HEAD') {
-        bodyBuf = Buffer.alloc(0);
-    }
-    let headerText = '';
-    try {
-        headerText = readFileSync(headerOutPath, 'utf-8');
-    }
-    catch {
-        // best-effort
-    }
-    safeRm(tmp);
-    // After redirects curl writes one header block per hop; the LAST block is
-    // the response we actually want to expose to the caller.
-    const blocks = headerText.split(/\r?\n\r?\n/).map((b) => b.trim()).filter(Boolean);
-    const finalBlock = blocks[blocks.length - 1] || '';
-    const finalLines = finalBlock.split(/\r?\n/);
-    // Pull statusText off the HTTP/x.y NNN <reason> status line if present.
-    let statusText = '';
-    if (finalLines.length > 0 && finalLines[0].startsWith('HTTP/')) {
-        const match = finalLines[0].match(/^HTTP\/\S+\s+\d+\s*(.*)$/);
-        if (match)
-            statusText = match[1].trim();
-    }
-    const responseHeaders = new Headers();
-    for (const line of finalLines) {
-        if (line.startsWith('HTTP/'))
-            continue;
-        const colon = line.indexOf(':');
-        if (colon < 0)
-            continue;
-        const name = line.slice(0, colon).trim();
-        const value = line.slice(colon + 1).trim();
-        if (!name)
-            continue;
-        responseHeaders.append(name, value);
-    }
-    // Manual redirect handling so curl and node:https behave identically.
-    // 303 always downgrades to GET; 301/302 downgrade non-GET/HEAD to GET;
-    // 307/308 preserve method and body.
-    const location = responseHeaders.get('location');
-    if (status >= 300 && status < 400 && location && redirectCount < MAX_REDIRECTS) {
-        let nextUrl;
-        try {
-            nextUrl = new URL(location, url).toString();
-        }
-        catch (err) {
-            throw err;
-        }
-        const shouldDowngradeToGet = status === 303 ||
-            ((status === 301 || status === 302) && method !== 'GET' && method !== 'HEAD');
-        const nextInit = shouldDowngradeToGet
-            ? { ...init, method: 'GET', body: undefined }
-            : init;
-        return curlFetchOnce(nextUrl, nextInit, redirectCount + 1);
-    }
-    // Mirror the node-path warning on unexpected encoding so the diagnostics
-    // are consistent across platforms.
-    const enc = (responseHeaders.get('content-encoding') || '').toLowerCase().trim();
-    if (enc && enc !== 'identity') {
-        try {
-            process.stderr.write(`[http] warning: server returned Content-Encoding: ${enc} despite Accept-Encoding: identity; ` +
-                `body returned as raw bytes (${url}).\n`);
-        }
-        catch { /* ignore */ }
-    }
-    return {
-        ok: status >= 200 && status < 300,
-        status,
-        statusText,
-        headers: responseHeaders,
-        url: finalUrl,
-        async text() { return bodyBuf.toString('utf-8'); },
-        async json() { return JSON.parse(bodyBuf.toString('utf-8')); },
-        async arrayBuffer() {
-            const copy = new Uint8Array(bodyBuf.byteLength);
-            copy.set(bodyBuf);
-            return copy.buffer;
-        },
-    };
-}
-function safeRm(path) {
-    try {
-        rmSync(path, { recursive: true, force: true });
-    }
-    catch { /* best-effort */ }
-}

package/dist/utils/ignore-matcher.d.ts

@@ -1,47 +0,0 @@
-export interface IgnoreSets {
-    dirs: Set<string>;
-    files: Set<string>;
-    extensions: Set<string>;
-}
-export declare function defaultIgnoreSets(): IgnoreSets;
-interface ParsedGitignore {
-    dirs: Set<string>;
-    files: Set<string>;
-}
-/**
- * Parse a `.gitignore` file's contents into basename-level dir and file sets.
- *
- * Only the simple, basename-style patterns are extracted: `name`, `name/`,
- * `/name`, `/name/`. Patterns containing glob characters (`*`, `?`, `[`),
- * negations (`!`), comments (`#`) or path separators are skipped — handling
- * those correctly requires a full gitignore matcher, which the agent's
- * walkers do not need: the goal is to avoid descending into well-known huge
- * gitignored directories like `.bun-cache`, `.next`, `dist`, `coverage`.
- *
- * Patterns without a trailing slash are added to both `dirs` and `files`
- * because gitignore semantics apply to either, and basename-only matching
- * cannot tell them apart safely.
- */
-export declare function parseGitignoreContent(content: string): ParsedGitignore;
-/**
- * Build a combined IgnoreSets for `dir` by merging the static defaults with
- * simple patterns parsed from `dir`/.gitignore (if present).
- */
-export declare function buildIgnoreSets(dir: string): IgnoreSets;
-/**
- * Returns true if `filePath`'s basename matches any directory, file, or
- * extension in `sets`. Matching is intentionally basename-only so it can
- * be used as the predicate for chokidar's `ignored` option and for
- * recursive directory walkers without needing absolute-path bookkeeping.
- */
-export declare function isPathIgnored(filePath: string, sets: IgnoreSets): boolean;
-/**
- * Like isPathIgnored, but for a full repo-relative path (e.g. the output of
- * `git ls-files`) rather than a single traversal step. It also treats a path
- * as ignored when ANY parent directory segment is an ignored dir (e.g.
- * `worker/.bun-cache/x.js`). The chokidar watcher gets this for free because
- * it never descends into an ignored directory; a flat path list does not, so
- * callers staging untracked files must use this variant to match the watcher.
- */
-export declare function isRelPathIgnored(relPath: string, sets: IgnoreSets): boolean;
-export {};

package/dist/utils/ignore-matcher.js

@@ -1,132 +0,0 @@
-import { existsSync, readFileSync } from 'fs';
-import { basename, join } from 'path';
-const DEFAULT_DIR_NAMES = [
-    '.git',
-    'node_modules',
-    '.runwork',
-    // .bun-cache is bun's per-project package cache. It commonly grows into
-    // hundreds of MB / tens of thousands of files and is universally
-    // gitignored. Walking it on every dev startup made the CLI lock-contend
-    // on file descriptors and never spawn the dev server.
-    '.bun-cache',
-];
-const DEFAULT_FILE_NAMES = [
-    '.dev.vars',
-    '.env',
-];
-const DEFAULT_EXTENSIONS = [
-    '.log',
-];
-export function defaultIgnoreSets() {
-    return {
-        dirs: new Set(DEFAULT_DIR_NAMES),
-        files: new Set(DEFAULT_FILE_NAMES),
-        extensions: new Set(DEFAULT_EXTENSIONS),
-    };
-}
-const GLOB_CHARS = /[*?\[\]]/;
-/**
- * Parse a `.gitignore` file's contents into basename-level dir and file sets.
- *
- * Only the simple, basename-style patterns are extracted: `name`, `name/`,
- * `/name`, `/name/`. Patterns containing glob characters (`*`, `?`, `[`),
- * negations (`!`), comments (`#`) or path separators are skipped — handling
- * those correctly requires a full gitignore matcher, which the agent's
- * walkers do not need: the goal is to avoid descending into well-known huge
- * gitignored directories like `.bun-cache`, `.next`, `dist`, `coverage`.
- *
- * Patterns without a trailing slash are added to both `dirs` and `files`
- * because gitignore semantics apply to either, and basename-only matching
- * cannot tell them apart safely.
- */
-export function parseGitignoreContent(content) {
-    const dirs = new Set();
-    const files = new Set();
-    for (const rawLine of content.split('\n')) {
-        const line = rawLine.trim();
-        if (!line || line.startsWith('#'))
-            continue;
-        if (line.startsWith('!'))
-            continue;
-        if (GLOB_CHARS.test(line))
-            continue;
-        let pattern = line;
-        const isDirOnly = pattern.endsWith('/');
-        if (isDirOnly)
-            pattern = pattern.slice(0, -1);
-        if (pattern.startsWith('/'))
-            pattern = pattern.slice(1);
-        if (!pattern)
-            continue;
-        if (pattern.includes('/'))
-            continue;
-        if (isDirOnly) {
-            dirs.add(pattern);
-        }
-        else {
-            dirs.add(pattern);
-            files.add(pattern);
-        }
-    }
-    return { dirs, files };
-}
-function loadGitignoreFromDir(dir) {
-    const path = join(dir, '.gitignore');
-    if (!existsSync(path))
-        return { dirs: new Set(), files: new Set() };
-    try {
-        return parseGitignoreContent(readFileSync(path, 'utf-8'));
-    }
-    catch {
-        return { dirs: new Set(), files: new Set() };
-    }
-}
-/**
- * Build a combined IgnoreSets for `dir` by merging the static defaults with
- * simple patterns parsed from `dir`/.gitignore (if present).
- */
-export function buildIgnoreSets(dir) {
-    const sets = defaultIgnoreSets();
-    const parsed = loadGitignoreFromDir(dir);
-    for (const name of parsed.dirs)
-        sets.dirs.add(name);
-    for (const name of parsed.files)
-        sets.files.add(name);
-    return sets;
-}
-/**
- * Returns true if `filePath`'s basename matches any directory, file, or
- * extension in `sets`. Matching is intentionally basename-only so it can
- * be used as the predicate for chokidar's `ignored` option and for
- * recursive directory walkers without needing absolute-path bookkeeping.
- */
-export function isPathIgnored(filePath, sets) {
-    const name = basename(filePath);
-    if (sets.dirs.has(name))
-        return true;
-    if (sets.files.has(name))
-        return true;
-    const dotIndex = name.lastIndexOf('.');
-    if (dotIndex >= 0) {
-        const ext = name.slice(dotIndex);
-        if (sets.extensions.has(ext))
-            return true;
-    }
-    return false;
-}
-/**
- * Like isPathIgnored, but for a full repo-relative path (e.g. the output of
- * `git ls-files`) rather than a single traversal step. It also treats a path
- * as ignored when ANY parent directory segment is an ignored dir (e.g.
- * `worker/.bun-cache/x.js`). The chokidar watcher gets this for free because
- * it never descends into an ignored directory; a flat path list does not, so
- * callers staging untracked files must use this variant to match the watcher.
- */
-export function isRelPathIgnored(relPath, sets) {
-    const segments = relPath.split('/');
-    for (let i = 0; i < segments.length - 1; i++) {
-        if (sets.dirs.has(segments[i]))
-            return true;
-    }
-    return isPathIgnored(relPath, sets);
-}

package/dist/utils/output.d.ts

@@ -1,17 +0,0 @@
-/**
- * JSON output utilities for agent-friendly CLI.
- *
- * When stdout is not a TTY (piped/captured by an agent), output switches
- * to machine-readable JSON automatically. The --json flag forces it.
- */
-/**
- * Determine whether to output JSON based on:
- * 1. Explicit --json flag (true)
- * 2. Explicit --no-json flag (false)
- * 3. Auto-detect: non-TTY stdout means agent/pipe, output JSON
- */
-export declare function shouldOutputJson(jsonFlag: boolean | undefined): boolean;
-/** Write a single JSON object to stdout (for one-shot commands). */
-export declare function jsonOut(data: unknown): void;
-/** Write one NDJSON line to stdout (for streaming commands). */
-export declare function jsonLine(data: unknown): void;

package/dist/utils/output.js

@@ -1,27 +0,0 @@
-/**
- * JSON output utilities for agent-friendly CLI.
- *
- * When stdout is not a TTY (piped/captured by an agent), output switches
- * to machine-readable JSON automatically. The --json flag forces it.
- */
-/**
- * Determine whether to output JSON based on:
- * 1. Explicit --json flag (true)
- * 2. Explicit --no-json flag (false)
- * 3. Auto-detect: non-TTY stdout means agent/pipe, output JSON
- */
-export function shouldOutputJson(jsonFlag) {
-    if (jsonFlag === true)
-        return true;
-    if (jsonFlag === false)
-        return false;
-    return !process.stdout.isTTY;
-}
-/** Write a single JSON object to stdout (for one-shot commands). */
-export function jsonOut(data) {
-    process.stdout.write(JSON.stringify(data) + '\n');
-}
-/** Write one NDJSON line to stdout (for streaming commands). */
-export function jsonLine(data) {
-    process.stdout.write(JSON.stringify(data) + '\n');
-}

package/dist/utils/prompt.d.ts

@@ -1,5 +0,0 @@
-export declare function promptSelect<T extends {
-    label: string;
-}>(message: string, choices: T[]): Promise<T>;
-export declare function promptInput(message: string, defaultValue?: string): Promise<string>;
-export declare function promptConfirm(message: string): Promise<boolean>;