promigence 0.1.0-beta.12

package/dist/agent.js

@@ -0,0 +1,374 @@
+import { DEFAULT_SNAPSHOT, PromigenceError, checkImageRef, checkRepoUrl, imageSnapshot, } from "./sdk/index.js";
+import { snapshotArg } from "./bundle.js";
+import { bool, client, nexts, spendCap, str, waitBound, } from "./commands.js";
+import { emit, errorEnvelope, errorTextLines, okEnvelope, parseDuration, usageError, write, } from "./io.js";
+import { findCommand } from "./surface.js";
+import { LIVE_HANDLERS } from "./live.js";
+import { escapeLine, jsonLine, sh, shellArg } from "./term.js";
+export const AGENT_CLIS = {
+    claude: {
+        bin: "claude",
+        pkg: "@anthropic-ai/claude-code@2.1.278",
+        defaultSecret: "ANTHROPIC_API_KEY",
+        keyVars: ["ANTHROPIC_API_KEY"],
+        headless: 'IS_SANDBOX=1 exec claude -p "$1" --dangerously-skip-permissions < /dev/null',
+    },
+    codex: {
+        bin: "codex",
+        pkg: "@openai/codex@0.155.1",
+        defaultSecret: "OPENAI_API_KEY",
+        keyVars: ["OPENAI_API_KEY", "CODEX_API_KEY"],
+        headless: 'exec codex exec --skip-git-repo-check --dangerously-bypass-approvals-and-sandbox "$1" < /dev/null',
+    },
+    opencode: {
+        bin: "opencode",
+        pkg: "opencode-ai@1.18.31",
+        defaultSecret: "ANTHROPIC_API_KEY",
+        keyVars: ["ANTHROPIC_API_KEY"],
+        headless: 'exec opencode run "$1" < /dev/null',
+    },
+};
+export const AGENT_NAMES = Object.keys(AGENT_CLIS);
+function withModelFlag(headless) {
+    return headless.replace(/(exec (?:claude -p "\$1"|codex exec|opencode run))/, '$1 --model "$2"');
+}
+export const SETUP_SCRIPT = [
+    "set -e",
+    'export HOME="${HOME:-/root}"',
+    'if ! command -v "$1" >/dev/null 2>&1; then',
+    '  command -v npm >/dev/null 2>&1 || { echo "neither $1 nor npm is in this snapshot: use one with Node.js, or with $1 installed" >&2; exit 127; }',
+    '  npm install -g --no-audit --no-fund --loglevel=error "$2" >&2',
+    "fi",
+    'if [ -n "$3" ] && [ ! -d "$4/.git" ]; then',
+    '  mkdir -p "$(dirname "$4")"',
+    '  git clone --quiet -- "$3" "$4" >&2',
+    '  if [ -n "${5:-}" ]; then chown -R -- "$5" "$4"; fi',
+    "fi",
+    '"$1" --version',
+].join("\n");
+async function snapshotUser(c, snapshot) {
+    if (snapshot === DEFAULT_SNAPSHOT)
+        return undefined;
+    const rec = await c.snapshots.get(snapshot).catch(() => undefined);
+    const u = rec?.user;
+    return typeof u === "string" && u !== "" && u !== "root" && u !== "0" ? u : undefined;
+}
+export function repoDir(url) {
+    const last = url.replace(/[/]+$/, "").split(/[/:]/).pop() ?? "";
+    const name = last.replace(/\.git$/, "").replace(/[^A-Za-z0-9._-]/g, "") || "repo";
+    return `/work/${name === "." || name === ".." ? "repo" : name}`;
+}
+function checkRepo(url) {
+    checkRepoUrl(url, "--repo");
+    const ok = /^(https?|git|ssh):\/\/[^\s]+$/.test(url) || /^[\w.-]+@[\w.-]+:[^\s]+$/.test(url);
+    if (!ok) {
+        throw usageError(`--repo: '${url}' is not a git URL`, "Pass --repo https://github.com/owner/name (a public repository).");
+    }
+}
+const PROVIDER_OF_VAR = {
+    ANTHROPIC_API_KEY: "Anthropic", OPENAI_API_KEY: "OpenAI", CODEX_API_KEY: "OpenAI",
+    GEMINI_API_KEY: "Google", GOOGLE_API_KEY: "Google", XAI_API_KEY: "xAI",
+};
+const OPENCODE_PROVIDER_VAR = {
+    anthropic: "ANTHROPIC_API_KEY", openai: "OPENAI_API_KEY", xai: "XAI_API_KEY", google: "GEMINI_API_KEY",
+};
+const OWN_PROVIDER = {
+    claude: { id: "anthropic", name: "Anthropic" }, codex: { id: "openai", name: "OpenAI" },
+};
+function withModel(which, agent, model) {
+    if (model === undefined)
+        return { agent };
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,127}$/.test(model)) {
+        throw usageError(`--model '${model}' is not a model name`, "Pass the provider's model id, e.g. --model xai/grok-4-0709 (opencode) or --model claude-sonnet-4-5 (claude).");
+    }
+    const own = OWN_PROVIDER[which];
+    if (own) {
+        const slash = model.indexOf("/");
+        if (slash < 0)
+            return { agent, model };
+        const provider = model.slice(0, slash).toLowerCase();
+        if (provider === own.id)
+            return { agent, model: model.slice(slash + 1) };
+        throw usageError(`${which} runs ${own.name} models; --model ${model} is another provider's`, `For that model: ${sh `promigence agent start opencode --model ${model}`} with that provider's key (--key-secret NAME=VAR).`);
+    }
+    const slash = model.indexOf("/");
+    if (slash <= 0 || slash === model.length - 1) {
+        throw usageError(`opencode takes --model as provider/model, got '${model}'`, "Name the provider first, e.g. --model xai/grok-4-0709 or --model anthropic/claude-sonnet-4-5.");
+    }
+    const v = OPENCODE_PROVIDER_VAR[model.slice(0, slash).toLowerCase()];
+    return { agent: v ? { ...agent, defaultSecret: v, keyVars: [v] } : agent, model };
+}
+const an = (word) => (/^[AEIOU]/.test(word) ? "an" : "a");
+function keyBindings(agent, spec, agentName = agent.bin) {
+    let name = agent.defaultSecret;
+    let vars = agent.keyVars;
+    if (spec !== undefined) {
+        const eq = spec.indexOf("=");
+        if (eq === 0 || spec === "" || eq === spec.length - 1) {
+            throw usageError(`--key-secret '${spec}' is not NAME or NAME=VAR`, `Pass --key-secret ${agent.defaultSecret} or --key-secret MY_KEY=${agent.keyVars[0]}.`);
+        }
+        const theirs = PROVIDER_OF_VAR[spec];
+        const ours = PROVIDER_OF_VAR[agent.defaultSecret];
+        if (eq < 0 && theirs !== undefined && ours !== undefined && theirs !== ours) {
+            throw usageError(`--key-secret ${spec} is ${an(theirs)} ${theirs} key; ${agentName} here takes ${an(ours)} ${ours} key (${agent.keyVars[0]})`, `Store ${an(ours)} ${ours} key and pass --key-secret ${agent.defaultSecret}` +
+                `${theirs === "OpenAI" && ours !== "OpenAI" ? " (promigence agent start codex takes an OpenAI key)" : ""}. ` +
+                `To bind a stored secret to another variable on purpose, pass --key-secret NAME=VAR.`);
+        }
+        if (eq < 0)
+            name = spec;
+        else {
+            name = spec.slice(0, eq);
+            vars = [spec.slice(eq + 1), ...agent.keyVars.slice(1)];
+        }
+    }
+    const bindings = [...new Set(vars)].map((v) => (v === name ? name : { name, as: v }));
+    return { name, vars: [...new Set(vars)], bindings };
+}
+function terminalSecrets(agent, name, vars) {
+    const interactive = agent.bin === "codex" ? vars.slice(0, 1) : vars;
+    return interactive.map((v) => (v === name ? name : `${name}=${v}`));
+}
+function attachCommand(sid, agent, secrets, cwd, model) {
+    return `promigence sandbox shell ${shellArg(sid)}${cwd ? ` --cwd ${shellArg(cwd)}` : ""} ${secrets.map((x) => `--secret ${shellArg(x)}`).join(" ")} -- ${agent.bin}${model ? ` --model ${shellArg(model)}` : ""}`;
+}
+function fail(ctx, err, exit, fields, next) {
+    const env = { ...errorEnvelope(ctx.cmd.name, err, next), ...fields };
+    return emit(ctx.mode, env, errorTextLines(ctx.cmd.name, err, exit, next), exit, ctx.pointer);
+}
+function checkSource(ctx) {
+    const image = str(ctx, "--image");
+    if (image === undefined)
+        return;
+    if (str(ctx, "--snapshot") !== undefined) {
+        throw usageError("agent start takes --snapshot or --image, not both", "Pick one; with neither, the agent is installed into promigence/base.");
+    }
+    checkImageRef(image);
+}
+async function snapshotFor(ctx, c) {
+    const image = str(ctx, "--image");
+    if (image !== undefined) {
+        await write(process.stderr, ctx.mode === "json"
+            ? jsonLine(process.stderr, { hint: "image snapshot", image })
+            : `image ${image}: creating or reusing its snapshot (a first build takes minutes)\n`);
+        return imageSnapshot(c, { image });
+    }
+    return str(ctx, "--snapshot") === undefined ? DEFAULT_SNAPSHOT : snapshotArg(ctx, c);
+}
+const EARLY_EXIT_WAIT_MS = 8_000;
+const PROVIDER_WATCH_MS = 30_000;
+const PROVIDER_POLL_MS = 1_000;
+const PROVIDER_REFUSALS = [
+    { kind: "credit", re: /no credits remaining/i },
+    { kind: "credit", re: /credit balance is too low/i },
+    { kind: "credit", re: /insufficient_quota|exceeded your current quota/i },
+    { kind: "credit", re: /doesn'?t have any credits|purchase credits|spending limit/i },
+    { kind: "credit", re: /you'?ve hit your usage limit/i },
+    { kind: "key", re: /incorrect api key provided|invalid_api_key/i },
+    { kind: "key", re: /invalid (?:x-)?api[ -]key|authentication_error|please run \/login/i },
+    { kind: "key", re: /unexpected status 40[13]\b/i },
+    { kind: "key", re: /API key is missing\. Pass it using/i },
+];
+function providerOf(vars) {
+    return vars.map((v) => PROVIDER_OF_VAR[v]).find((p) => p !== undefined) ?? "the model provider";
+}
+export function providerRefusal(text) {
+    for (const line of text.split("\n")) {
+        const hit = PROVIDER_REFUSALS.find((p) => p.re.test(line));
+        if (hit)
+            return { kind: hit.kind, line: line.trim().slice(0, 200) };
+    }
+    return undefined;
+}
+async function watchForRefusal(c, sid, execId, until) {
+    const at = { stdout: 0, stderr: 0 };
+    let tail = "";
+    for (;;) {
+        let running = true;
+        for (const stream of ["stdout", "stderr"]) {
+            const r = await c.sandboxes.execs.read(sid, execId, stream, { offset: at[stream], len: 65_536 }).catch(() => undefined);
+            if (!r)
+                continue;
+            at[stream] = r.offset + r.data.length;
+            tail = (tail + new TextDecoder().decode(r.data)).slice(-16_384);
+            running = r.record.state === "running";
+        }
+        const hit = providerRefusal(tail);
+        if (hit || !running || Date.now() + PROVIDER_POLL_MS > until)
+            return hit;
+        await new Promise((res) => setTimeout(res, PROVIDER_POLL_MS));
+    }
+}
+async function lastLines(c, sid, execId) {
+    const out = [];
+    for (const stream of ["stderr", "stdout"]) {
+        const r = await c.sandboxes.execs.read(sid, execId, stream).catch(() => undefined);
+        const text = r ? new TextDecoder().decode(r.data).trim() : "";
+        if (text)
+            out.push(...text.split("\n").slice(-3));
+    }
+    return escapeLine(out.join(" | ").slice(-400));
+}
+const agentStart = async (ctx) => {
+    const which = ctx.args[0];
+    if (which === undefined) {
+        throw usageError("agent start needs an agent", `Pass one of ${AGENT_NAMES.join(" | ")}, e.g. promigence agent start claude.`);
+    }
+    if (ctx.args.length > 1) {
+        throw usageError(`agent start takes one agent, got ${ctx.args.length}`, "Quote a task and pass it as --prompt TEXT.");
+    }
+    const known = AGENT_CLIS[which];
+    if (known === undefined) {
+        throw usageError(`unknown agent '${which}'`, `Pick one of ${AGENT_NAMES.join(" | ")}.`);
+    }
+    const { agent, model } = withModel(which, known, str(ctx, "--model"));
+    const key = keyBindings(agent, str(ctx, "--key-secret"), which);
+    const fromEnv = str(ctx, "--key-from-env");
+    let keyValue;
+    if (fromEnv !== undefined) {
+        keyValue = process.env[fromEnv];
+        if (!keyValue) {
+            throw usageError(`--key-from-env ${fromEnv}: the variable is empty or unset`, `Export it first (export ${fromEnv}=...), or store the key once: ${sh `promigence secrets set ${key.name} --from-env ${fromEnv}`}.`);
+        }
+    }
+    checkSource(ctx);
+    const repo = str(ctx, "--repo");
+    if (repo !== undefined)
+        checkRepo(repo);
+    const prompt = str(ctx, "--prompt");
+    if (prompt !== undefined && prompt.trim() === "")
+        throw usageError("--prompt is empty", "Pass the task: --prompt 'fix the failing test'.");
+    const attach = bool(ctx, "--attach");
+    if (attach && prompt !== undefined) {
+        throw usageError("--attach starts the agent in a terminal; --prompt runs it headless", "Pick one.");
+    }
+    if (attach && !(process.stdin.isTTY && process.stdout.isTTY)) {
+        throw usageError("--attach needs a terminal", "Run it from an interactive shell, or leave --attach off and run the printed attach command.");
+    }
+    const timeout = str(ctx, "--timeout");
+    const timeoutMs = timeout === undefined ? 60 * 60_000 : parseDuration(timeout, "--timeout");
+    const cwd = repo === undefined ? undefined : repoDir(repo);
+    const c = client(ctx);
+    if (keyValue !== undefined)
+        await c.secrets.set(key.name, keyValue.replace(/\r?\n$/, ""));
+    keyValue = undefined;
+    const snapshot = await snapshotFor(ctx, c);
+    const started = await c.runs.start({
+        snapshot, count: 1, timeoutMs, spendCap: await spendCap(ctx, c), secrets: key.bindings,
+        labels: { agent: which },
+    });
+    const runId = started.run_id;
+    const bound = waitBound(ctx);
+    const waited = await c.runs.waitReady(runId, { waitTimeoutMs: bound });
+    const sb = waited.sandboxes.find((s) => s.state === "ready" || s.state === "running");
+    if (waited.timedOut || sb === undefined) {
+        const next = nexts([sh `promigence run report ${runId} --json`, "why it did not start"], [sh `promigence run kill ${runId}`, "stop waiting for it"]);
+        const err = waited.timedOut
+            ? new PromigenceError({ code: "timeout", message: `no sandbox ready within ${bound}ms; nothing was killed`, fix: `Wait with ${sh `promigence run status ${runId} --wait`}, or raise --wait-timeout.`, exitCode: 11 })
+            : new PromigenceError({ code: "env_failed", message: "the sandbox did not start", fix: `Read ${sh `promigence run report ${runId}`}; it was not billed.`, exitCode: 3 });
+        return fail(ctx, err, err.cliExit, { run_id: runId, sandboxes: waited.sandboxes }, next);
+    }
+    const sid = sb.sandbox_id;
+    const endOnThrow = async (p) => {
+        try {
+            return await p;
+        }
+        catch (e) {
+            await c.sandboxes.kill(sid).catch(() => undefined);
+            throw e;
+        }
+    };
+    const runAs = await snapshotUser(c, snapshot);
+    const setup = await endOnThrow(c.sandboxes.exec(sid, {
+        argv: ["sh", "-c", SETUP_SCRIPT, "agent-setup", agent.bin, agent.pkg, repo ?? "", cwd ?? "", runAs ?? ""],
+        user: "root",
+        timeoutMs: 10 * 60_000,
+    }));
+    if (setup.exit_code !== 0) {
+        await c.sandboxes.kill(sid).catch(() => undefined);
+        const tail = (setup.stderr ?? "").trim().split("\n").slice(-3).join(" | ").slice(0, 400);
+        const err = new PromigenceError({
+            code: "nonzero_exit",
+            message: `setting up ${agent.bin} failed (exit ${setup.exit_code ?? "none"}): ${tail || "no output"}`,
+            fix: `The sandbox was killed. Use a snapshot with ${agent.bin} or Node.js installed (--snapshot), or check --repo.`,
+            exitCode: 4,
+        });
+        return fail(ctx, err, 4, { run_id: runId, sandbox_id: sid, killed: true }, nexts([sh `promigence run report ${runId} --json`, "the sandbox's record"]));
+    }
+    const version = (setup.stdout ?? "").trim().split("\n").pop() ?? "";
+    const shellSecrets = terminalSecrets(agent, key.name, key.vars);
+    const attachCmd = attachCommand(sid, agent, shellSecrets, cwd, model);
+    const killCmd = sh `promigence sandbox kill ${sid}`;
+    const base = {
+        agent: which, version, run_id: runId, sandbox_id: sid, snapshot,
+        key_secret: key.name, key_vars: key.vars, ...(cwd ? { cwd } : {}),
+    };
+    if (prompt !== undefined) {
+        const rec = await endOnThrow(c.sandboxes.execBackground(sid, {
+            argv: model === undefined
+                ? ["sh", "-c", `export HOME="\${HOME:-/root}"; ${agent.headless}`, "agent", prompt]
+                : ["sh", "-c", `export HOME="\${HOME:-/root}"; ${withModelFlag(agent.headless)}`, "agent", prompt, model],
+            ...(cwd ? { cwd } : {}),
+            timeoutMs,
+        }));
+        const started = Date.now();
+        const early = await c.sandboxes.execs.get(sid, rec.exec_id, { waitMs: EARLY_EXIT_WAIT_MS }).catch(() => undefined);
+        const ended = early !== undefined && early.state !== "running";
+        const exitCode = early?.exit?.exit_code ?? null;
+        const signal = early?.exit?.signal ?? null;
+        if (ended && (exitCode !== 0 || signal !== null)) {
+            const said = await lastLines(c, sid, rec.exec_id);
+            await c.sandboxes.kill(sid).catch(() => undefined);
+            const err = new PromigenceError({
+                code: "nonzero_exit",
+                message: `${agent.bin} exited ${signal !== null ? `on signal ${signal}` : exitCode ?? "without an exit code"} within ${EARLY_EXIT_WAIT_MS / 1000} s of starting: ${said || "it wrote nothing"}`,
+                fix: `The sandbox was ended. A wrong or expired model key is the usual cause: store the right one (${sh `promigence secrets set ${key.name} --from-env ${key.name}`}) and start again.`,
+                exitCode: 4,
+            });
+            return fail(ctx, err, 4, { ...base, mode: "headless", exec_id: rec.exec_id, exit_code: exitCode, signal, killed: true }, nexts([sh `promigence run report ${runId} --json`, "the sandbox's record"]));
+        }
+        if (!ended) {
+            const window = Number(process.env["PROMIGENCE_AGENT_WATCH_MS"] ?? "") || PROVIDER_WATCH_MS;
+            if (ctx.mode === "text") {
+                await write(process.stderr, `watching ${agent.bin}'s first ${Math.round(window / 1000)} s for its provider refusing it (no credit, a bad key)...\n`);
+            }
+            const refused = await watchForRefusal(c, sid, rec.exec_id, started + window);
+            if (refused) {
+                await c.sandboxes.kill(sid).catch(() => undefined);
+                const provider = providerOf(key.vars);
+                const err = new PromigenceError({
+                    code: "nonzero_exit",
+                    message: `${provider} refused ${agent.bin}: ${refused.kind === "credit" ? "the account is out of credit" : "the key was not accepted"} (it said: ${escapeLine(refused.line)})`,
+                    fix: refused.kind === "credit"
+                        ? `The sandbox was ended. Add credit to your ${provider} account, then start again.`
+                        : `The sandbox was ended. Check the key: store the right one (${sh `promigence secrets set ${key.name} --from-env ${key.name}`}) and start again.`,
+                    exitCode: 4,
+                });
+                return fail(ctx, err, 4, { ...base, mode: "headless", exec_id: rec.exec_id, refused: refused.kind, killed: true }, nexts([sh `promigence run report ${runId} --json`, "the sandbox's record"]));
+            }
+        }
+        const next = nexts([sh `promigence exec output ${rec.exec_id} --sandbox ${sid} --follow`, "follow the agent until it exits"], [sh `promigence exec kill ${rec.exec_id} --sandbox ${sid}`, "stop the agent"], [killCmd, "end the sandbox (billing stops)"]);
+        return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...base, mode: "headless", exec_id: rec.exec_id, stop: [next[1].cmd, killCmd] }, next), [
+            `agent ${which} ${version} working in ${sid} (run ${runId})`,
+            `  follow: ${next[0].cmd}`,
+            `  stop:   ${next[1].cmd}  ·  ${killCmd}`,
+        ], 0, ctx.pointer);
+    }
+    const next = nexts([attachCmd, "open a terminal running the agent"], [killCmd, "end the sandbox (billing stops)"]);
+    if (attach) {
+        await write(process.stderr, `agent ${which} ${escapeLine(version)} ready in ${sid}; exit it, then: ${killCmd}\n`);
+        const shell = findCommand(["sandbox", "shell"]);
+        const flags = new Map();
+        if (cwd)
+            flags.set("--cwd", [cwd]);
+        flags.set("--secret", shellSecrets);
+        return LIVE_HANDLERS["sandbox shell"]({ ...ctx, cmd: shell, args: [sid], flags, cmdTail: [agent.bin], pointer: false });
+    }
+    return emit(ctx.mode, okEnvelope(ctx.cmd.name, { ...base, mode: "interactive", attach: attachCmd, stop: [killCmd] }, next), [
+        `agent ${which} ${version} ready in ${sid} (run ${runId})`,
+        `  attach: ${attachCmd}`,
+        `  stop:   exit the agent, then ${killCmd}`,
+    ], 0, ctx.pointer);
+};
+export const AGENT_HANDLERS = {
+    "agent start": agentStart,
+};

package/dist/argv.js

@@ -0,0 +1,159 @@
+import { GLOBAL_FLAGS, findCommand, knownFlags } from "./surface.js";
+function empty() {
+    return { words: [], flags: new Map(), cmdTail: [], help: false, version: false };
+}
+function add(p, name, value) {
+    const cur = p.flags.get(name);
+    if (cur)
+        cur.push(value);
+    else
+        p.flags.set(name, [value]);
+}
+function global(p, a) {
+    if (a === "--help" || a === "-h") {
+        p.help = true;
+        return true;
+    }
+    if (a === "--version" || a === "-V") {
+        p.version = true;
+        return true;
+    }
+    if (a === "--json") {
+        p.modeFlag = "json";
+        return true;
+    }
+    if (a === "--text") {
+        p.modeFlag = "text";
+        return true;
+    }
+    return false;
+}
+function parsePlain(argv) {
+    const p = empty();
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--") {
+            p.cmdTail = argv.slice(i + 1);
+            break;
+        }
+        if (global(p, a))
+            continue;
+        if (a.startsWith("--")) {
+            const eq = a.indexOf("=");
+            if (eq > 0)
+                add(p, a.slice(0, eq), a.slice(eq + 1));
+            else if (i + 1 < argv.length && !argv[i + 1].startsWith("-"))
+                add(p, a, argv[++i]);
+            else
+                add(p, a, true);
+            continue;
+        }
+        p.words.push(a);
+    }
+    return p;
+}
+export function positionalsBeforeTail(c) {
+    const words = (c.args ?? "").split(/\s+/).filter(Boolean);
+    const at = words.findIndex((w) => w === "--" || w === "[--");
+    return at < 0 ? words.length : at;
+}
+export const takesTail = (c) => /(^|\s)\[?--(\s|$)/.test(c.args ?? "");
+const isShortFlag = (a) => /^-[A-Za-z]/.test(a);
+function shapedFlag(p, argv, i, known, withValue) {
+    const a = argv[i];
+    const eq = a.indexOf("=");
+    if (a.startsWith("--") && eq > 0) {
+        add(p, a.slice(0, eq), a.slice(eq + 1));
+        return 0;
+    }
+    const next = argv[i + 1];
+    if (withValue.has(a)) {
+        if (next !== undefined && !next.startsWith("--")) {
+            add(p, a, next);
+            return 1;
+        }
+        add(p, a, true);
+        return 0;
+    }
+    if (known.has(a) || isShortFlag(a)) {
+        add(p, a, true);
+        return 0;
+    }
+    if (next !== undefined && !next.startsWith("-")) {
+        add(p, a, next);
+        return 1;
+    }
+    add(p, a, true);
+    return 0;
+}
+function shapes(cmd) {
+    const withValue = new Set();
+    for (const f of [...GLOBAL_FLAGS, ...cmd.flags])
+        if (f.arg)
+            withValue.add(f.name);
+    return { known: knownFlags(cmd), withValue };
+}
+function parseShaped(argv, cmd) {
+    const p = empty();
+    const { known, withValue } = shapes(cmd);
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--") {
+            p.cmdTail = argv.slice(i + 1);
+            break;
+        }
+        if (global(p, a))
+            continue;
+        if (a.startsWith("--") || isShortFlag(a)) {
+            i += shapedFlag(p, argv, i, known, withValue);
+            continue;
+        }
+        p.words.push(a);
+    }
+    return p;
+}
+function parseWithTail(argv, cmd) {
+    const p = empty();
+    const { known, withValue } = shapes(cmd);
+    const room = cmd.name.split(" ").length + positionalsBeforeTail(cmd);
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--" && p.words.length >= cmd.name.split(" ").length) {
+            p.cmdTail = argv.slice(i + 1);
+            break;
+        }
+        if (global(p, a))
+            continue;
+        if (a.startsWith("--") || isShortFlag(a)) {
+            i += shapedFlag(p, argv, i, known, withValue);
+            continue;
+        }
+        if (p.words.length < room) {
+            p.words.push(a);
+            continue;
+        }
+        p.cmdTail = argv.slice(i);
+        break;
+    }
+    return p;
+}
+export function parse(argv, platform = process.platform) {
+    const plain = parsePlain(argv);
+    const lead = [];
+    for (const a of argv) {
+        if (a.startsWith("-"))
+            break;
+        lead.push(a);
+    }
+    const cmd = (lead.length ? findCommand(lead) : undefined) ?? findCommand(plain.words);
+    if (!cmd)
+        return plain;
+    if (platform === "win32" && takesTail(cmd)) {
+        const cut = argv.indexOf("--");
+        const before = cut < 0 ? argv : argv.slice(0, cut);
+        const overflow = parseShaped(before, cmd).words.length > cmd.name.split(" ").length + positionalsBeforeTail(cmd);
+        if (cut < 0 || overflow)
+            return parseWithTail(argv, cmd);
+    }
+    return parseShaped(argv, cmd);
+}