runwork 0.15.1 → 0.15.2

package/dist/utils/curl-parser.js

@@ -1,162 +0,0 @@
-/** Headers that should be stripped -- the integration proxy handles auth */
-const STRIPPED_HEADERS = new Set(['host', 'authorization', 'cookie', 'connection', 'user-agent']);
-/**
- * Tokenize a curl command string, respecting single/double quotes and backslash continuations.
- */
-function tokenize(input) {
-    // Normalize backslash-newline continuations into a single line
-    const normalized = input.replace(/\\\s*\n\s*/g, ' ');
-    const tokens = [];
-    let i = 0;
-    while (i < normalized.length) {
-        // Skip whitespace
-        if (/\s/.test(normalized[i])) {
-            i++;
-            continue;
-        }
-        // Quoted string
-        if (normalized[i] === "'" || normalized[i] === '"') {
-            const quote = normalized[i];
-            let token = '';
-            i++; // skip opening quote
-            while (i < normalized.length && normalized[i] !== quote) {
-                if (normalized[i] === '\\' && quote === '"' && i + 1 < normalized.length) {
-                    token += normalized[i + 1];
-                    i += 2;
-                }
-                else {
-                    token += normalized[i];
-                    i++;
-                }
-            }
-            i++; // skip closing quote
-            tokens.push(token);
-            continue;
-        }
-        // Unquoted token
-        let token = '';
-        while (i < normalized.length && !/\s/.test(normalized[i])) {
-            token += normalized[i];
-            i++;
-        }
-        tokens.push(token);
-    }
-    return tokens;
-}
-/** Flags that take no argument (should be skipped, not consumed as URL) */
-const NO_ARG_FLAGS = new Set([
-    '--compressed', '-s', '--silent', '-S', '--show-error',
-    '-L', '--location', '-v', '--verbose', '-k', '--insecure',
-    '-I', '--head', '-i', '--include', '-N', '--no-buffer',
-    '--fail', '-f', '--globoff', '-g',
-]);
-/** Flags that take one argument (flag + value should both be consumed) */
-const ONE_ARG_FLAGS = new Set([
-    '-o', '--output', '-u', '--user', '-A', '--user-agent',
-    '-e', '--referer', '-b', '--cookie', '-c', '--cookie-jar',
-    '--connect-timeout', '-m', '--max-time', '--retry',
-    '-w', '--write-out', '--resolve', '--proxy', '-x',
-    '--cert', '--key', '--cacert', '-T', '--upload-file',
-]);
-/**
- * Parse a curl command string into a structured request.
- * Pure JS implementation, no native dependencies.
- */
-export async function parseCurlToRequest(curlStr) {
-    const trimmed = curlStr.trim();
-    if (!trimmed) {
-        throw new Error('Could not parse curl command -- empty input.');
-    }
-    const tokens = tokenize(trimmed);
-    // Skip leading "curl" token
-    let start = 0;
-    if (tokens[start] === 'curl')
-        start++;
-    let url;
-    let method;
-    const headers = {};
-    let dataStr;
-    for (let i = start; i < tokens.length; i++) {
-        const token = tokens[i];
-        if (token === '-X' || token === '--request') {
-            method = tokens[++i];
-            continue;
-        }
-        if (token === '-H' || token === '--header') {
-            const headerVal = tokens[++i];
-            if (headerVal) {
-                const colonIdx = headerVal.indexOf(':');
-                if (colonIdx > 0) {
-                    const key = headerVal.slice(0, colonIdx);
-                    const value = headerVal.slice(colonIdx + 1).trimStart();
-                    headers[key] = value;
-                }
-            }
-            continue;
-        }
-        if (token === '-d' || token === '--data' || token === '--data-raw' || token === '--data-binary') {
-            dataStr = tokens[++i];
-            continue;
-        }
-        if (NO_ARG_FLAGS.has(token)) {
-            continue;
-        }
-        if (ONE_ARG_FLAGS.has(token)) {
-            i++; // skip the argument
-            continue;
-        }
-        // If it looks like a URL (starts with http or has ://) and we don't have one yet
-        if (!url && (token.startsWith('http://') || token.startsWith('https://') || token.includes('://'))) {
-            url = token;
-            continue;
-        }
-        // If it doesn't start with '-' and we don't have a URL, treat as URL
-        if (!url && !token.startsWith('-')) {
-            url = token;
-            continue;
-        }
-    }
-    if (!url) {
-        throw new Error('Could not parse curl command -- no URL found.');
-    }
-    // Infer method: POST if data is present, otherwise GET
-    if (!method) {
-        method = dataStr !== undefined ? 'POST' : 'GET';
-    }
-    // Parse URL
-    const parsedUrl = new URL(url);
-    const path = parsedUrl.pathname;
-    const query = parsedUrl.search ? parsedUrl.search.slice(1) : undefined;
-    // Strip proxy-managed headers
-    const filteredHeaders = {};
-    for (const [key, val] of Object.entries(headers)) {
-        if (!STRIPPED_HEADERS.has(key.toLowerCase())) {
-            filteredHeaders[key] = val;
-        }
-    }
-    // Parse body
-    let body;
-    if (dataStr !== undefined && dataStr !== '') {
-        // Try JSON first
-        try {
-            body = JSON.parse(dataStr);
-        }
-        catch {
-            // Try form-encoded: key=value&key=value
-            if (dataStr.includes('=') && !dataStr.includes('{')) {
-                const formData = {};
-                for (const pair of dataStr.split('&')) {
-                    const eqIdx = pair.indexOf('=');
-                    if (eqIdx > 0) {
-                        formData[decodeURIComponent(pair.slice(0, eqIdx))] = decodeURIComponent(pair.slice(eqIdx + 1));
-                    }
-                }
-                body = formData;
-            }
-            else {
-                body = dataStr;
-            }
-        }
-    }
-    return { method: method.toUpperCase(), path, query, headers: filteredHeaders, body };
-}

package/dist/utils/data-input.d.ts

@@ -1 +0,0 @@
-export declare function parseDataInput(dataFlag?: string): Promise<Record<string, unknown>>;

package/dist/utils/data-input.js

@@ -1,38 +0,0 @@
-import { readFileSync, existsSync } from 'fs';
-export async function parseDataInput(dataFlag) {
-    if (dataFlag) {
-        if (dataFlag.startsWith('@')) {
-            const filePath = dataFlag.slice(1);
-            if (!existsSync(filePath)) {
-                console.error(`File not found: ${filePath}`);
-                process.exit(1);
-            }
-            const content = readFileSync(filePath, 'utf-8');
-            return parseJson(content, filePath);
-        }
-        return parseJson(dataFlag, '--data');
-    }
-    if (!process.stdin.isTTY) {
-        const chunks = [];
-        for await (const chunk of process.stdin) {
-            chunks.push(chunk);
-        }
-        const content = Buffer.concat(chunks).toString('utf-8').trim();
-        if (!content) {
-            console.error('No data provided via stdin.');
-            process.exit(1);
-        }
-        return parseJson(content, 'stdin');
-    }
-    console.error('No data provided. Use --data \'{"key": "value"}\', --data @file.json, or pipe JSON via stdin.');
-    process.exit(1);
-}
-function parseJson(content, source) {
-    try {
-        return JSON.parse(content);
-    }
-    catch {
-        console.error(`Invalid JSON from ${source}: ${content.slice(0, 100)}`);
-        process.exit(1);
-    }
-}

package/dist/utils/format-error.d.ts

@@ -1,10 +0,0 @@
-/**
- * Render an unknown thrown value as a single human-readable line. Tailored
- * for `execFileSync` failures (which carry stderr/stdout buffers, an `errno`
- * code, and a `message` like "Command failed: git ...") so the most useful
- * piece of information surfaces first.
- *
- * Used by command entry points that have a `stdio: 'pipe'` git invocation
- * to keep the diagnostic from being silently dropped.
- */
-export declare function formatError(err: unknown): string;

package/dist/utils/format-error.js

@@ -1,38 +0,0 @@
-/**
- * Render an unknown thrown value as a single human-readable line. Tailored
- * for `execFileSync` failures (which carry stderr/stdout buffers, an `errno`
- * code, and a `message` like "Command failed: git ...") so the most useful
- * piece of information surfaces first.
- *
- * Used by command entry points that have a `stdio: 'pipe'` git invocation
- * to keep the diagnostic from being silently dropped.
- */
-export function formatError(err) {
-    if (!err)
-        return 'unknown error';
-    if (err instanceof Error) {
-        const obj = err;
-        const stderr = bufToStr(obj.stderr);
-        const stdout = bufToStr(obj.stdout);
-        const detail = stderr || stdout;
-        if (detail) {
-            // Common case for ENOENT: errno -> "git ENOENT: no such file or directory"
-            if (obj.code)
-                return `${obj.code}: ${detail}`;
-            return detail;
-        }
-        if (obj.code)
-            return `${obj.code}: ${obj.message}`;
-        return obj.message || String(err);
-    }
-    return String(err);
-}
-function bufToStr(value) {
-    if (!value)
-        return '';
-    if (typeof value === 'string')
-        return value.trim();
-    if (Buffer.isBuffer(value))
-        return value.toString('utf-8').trim();
-    return '';
-}

package/dist/utils/fs.d.ts

@@ -1,5 +0,0 @@
-/**
- * Remove .git directories nested at depth >= 2 under the given root.
- * Replaces `find <dir> -mindepth 2 -name .git -type d`.
- */
-export declare function removeNestedGitDirs(rootDir: string): void;

package/dist/utils/fs.js

@@ -1,23 +0,0 @@
-import { readdirSync, rmSync } from 'fs';
-import { join, relative, sep } from 'path';
-/**
- * Remove .git directories nested at depth >= 2 under the given root.
- * Replaces `find <dir> -mindepth 2 -name .git -type d`.
- */
-export function removeNestedGitDirs(rootDir) {
-    const entries = readdirSync(rootDir, { recursive: true, withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.name !== '.git' || !entry.isDirectory())
-            continue;
-        const parentPath = 'parentPath' in entry
-            ? entry.parentPath
-            : entry.path;
-        const fullPath = join(parentPath, entry.name);
-        const rel = relative(rootDir, fullPath);
-        const depth = rel.split(sep).length;
-        // Only remove .git dirs at depth >= 2 (not the root .git)
-        if (depth >= 2) {
-            rmSync(fullPath, { recursive: true, force: true });
-        }
-    }
-}

package/dist/utils/help-json.d.ts

@@ -1,70 +0,0 @@
-/**
- * JSON help output for AI agents.
- *
- * When --json is active (explicitly or via non-TTY), `runwork --help` and
- * `runwork <command> --help` output a machine-readable command tree instead
- * of Commander's human-readable text.
- *
- * This lets an agent discover the full CLI surface in a single call.
- */
-import type { Command } from 'commander';
-interface JsonOption {
-    flags: string;
-    description: string;
-    /**
-     * Whether the OPTION itself must be supplied (Commander's `mandatory`, set
-     * via `.makeOptionMandatory()`). This is what an agent reasoning about
-     * "do I have to pass this?" wants. Most options are false here even when
-     * they take a value -- e.g. `--workspace <id>` is optional (defaults from
-     * credentials). Previously this field was wrongly mapped to Commander's
-     * `required` (value-required), which marked nearly every option as required.
-     */
-    required: boolean;
-    /**
-     * Whether the option's VALUE is required when the flag is present, i.e. it
-     * was declared with `<value>` (vs `[value]` or a boolean flag). Independent
-     * of whether the option itself must be supplied.
-     */
-    valueRequired: boolean;
-    optional: boolean;
-    variadic: boolean;
-    defaultValue?: unknown;
-    choices?: string[];
-    envVar?: string;
-}
-interface JsonArgument {
-    name: string;
-    description: string;
-    required: boolean;
-    variadic: boolean;
-    defaultValue?: unknown;
-    choices?: string[];
-}
-interface JsonCommand {
-    name: string;
-    description: string;
-    aliases: string[];
-    usage: string;
-    options: JsonOption[];
-    arguments: JsonArgument[];
-    subcommands: JsonCommand[];
-}
-interface JsonHelpOutput {
-    version: string;
-    name: string;
-    description: string;
-    usage: string;
-    globalOptions: JsonOption[];
-    commands: JsonCommand[];
-}
-/**
- * Serialize the full command tree to a JSON-friendly structure.
- */
-export declare function buildHelpJson(program: Command): JsonHelpOutput;
-/**
- * Serialize a single command (for `runwork <cmd> --help --json`).
- */
-export declare function buildCommandHelpJson(cmd: Command, version: string): JsonCommand & {
-    version: string;
-};
-export {};

package/dist/utils/help-json.js

@@ -1,88 +0,0 @@
-/**
- * JSON help output for AI agents.
- *
- * When --json is active (explicitly or via non-TTY), `runwork --help` and
- * `runwork <command> --help` output a machine-readable command tree instead
- * of Commander's human-readable text.
- *
- * This lets an agent discover the full CLI surface in a single call.
- */
-function serializeOption(opt) {
-    const result = {
-        flags: opt.flags,
-        description: opt.description,
-        // Commander's `mandatory` = the option must be supplied; `required` = the
-        // option's value is required when present. Expose both, correctly named.
-        required: opt.mandatory,
-        valueRequired: opt.required,
-        optional: opt.optional,
-        variadic: opt.variadic,
-    };
-    if (opt.defaultValue !== undefined)
-        result.defaultValue = opt.defaultValue;
-    if (opt.argChoices)
-        result.choices = opt.argChoices;
-    if (opt.envVar)
-        result.envVar = opt.envVar;
-    return result;
-}
-function serializeArgument(arg) {
-    const result = {
-        name: arg.name(),
-        description: arg.description,
-        required: arg.required,
-        variadic: arg.variadic,
-    };
-    if (arg.defaultValue !== undefined)
-        result.defaultValue = arg.defaultValue;
-    if (arg.argChoices)
-        result.choices = arg.argChoices;
-    return result;
-}
-function serializeCommand(cmd) {
-    const subcommands = cmd.commands
-        .filter((c) => !c._hidden)
-        .map(serializeCommand);
-    // Get command-level options (exclude inherited global options)
-    const options = cmd.options
-        .filter((o) => !o.hidden)
-        .map(serializeOption);
-    const registeredArguments = cmd.registeredArguments ?? [];
-    return {
-        name: cmd.name(),
-        description: cmd.description(),
-        aliases: cmd.aliases(),
-        usage: cmd.usage(),
-        options,
-        arguments: registeredArguments.map(serializeArgument),
-        subcommands,
-    };
-}
-/**
- * Serialize the full command tree to a JSON-friendly structure.
- */
-export function buildHelpJson(program) {
-    const globalOptions = program.options
-        .filter((o) => !o.hidden)
-        .map(serializeOption);
-    const commands = program.commands
-        .filter((c) => !c._hidden)
-        .map(serializeCommand);
-    return {
-        version: program.version() ?? 'unknown',
-        name: program.name(),
-        description: program.description(),
-        usage: program.usage(),
-        globalOptions,
-        commands,
-    };
-}
-/**
- * Serialize a single command (for `runwork <cmd> --help --json`).
- */
-export function buildCommandHelpJson(cmd, version) {
-    return {
-        version,
-        ...serializeCommand(cmd),
-    };
-}

package/dist/utils/http.d.ts

@@ -1,46 +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.
- */
-export interface HttpRequestInit {
-    method?: string;
-    headers?: Record<string, string | undefined> | Headers;
-    body?: string | Uint8Array | ArrayBuffer | Buffer | null;
-    /** Accepted for compatibility with `fetch(..., { cache: 'no-store' })`; ignored. */
-    cache?: string;
-    /** Accepted for compatibility; ignored (no AbortController support yet). */
-    signal?: AbortSignal;
-}
-export interface HttpResponse {
-    readonly ok: boolean;
-    readonly status: number;
-    readonly statusText: string;
-    readonly headers: Headers;
-    readonly url: string;
-    text(): Promise<string>;
-    json<T = unknown>(): Promise<T>;
-    arrayBuffer(): Promise<ArrayBuffer>;
-}
-/**
- * Available HTTP transports. `node` is the default everywhere. `curl` is an
- * opt-in escape hatch (set the `RUNWORK_HTTP_TRANSPORT=curl` env var) that
- * shells out to `curl.exe` / `curl` for each request, sidestepping the
- * runtime's native HTTP stack entirely. We keep it around as break-glass
- * for any future Bun runtime regression on Windows; see file header.
- */
-export type HttpTransport = 'auto' | 'node' | 'curl';
-export declare function __setTransportForTests(t: HttpTransport): void;
-export declare function httpFetch(url: string, init?: HttpRequestInit): Promise<HttpResponse>;