outsrc 0.2.0

package/dist/init.d.ts

@@ -0,0 +1,54 @@
+import { type PluginAdapter } from "./plugins.js";
+export type Cli = "claude" | "codex" | "grok";
+export type Run = {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};
+export type InitEnv = {
+    configPath: string;
+    serverCommand: string[];
+    which: (command: string) => string | null;
+    run: (command: string, args: string[]) => Run;
+    runInteractive: (command: string, args: string[]) => number | null;
+    runStreaming: (command: string, args: string[], onLine: (line: string) => void) => Promise<number | null>;
+    emit: (event: Record<string, unknown>) => void;
+    confirm: (question: string, fallback: boolean) => Promise<boolean>;
+    ask: (question: string) => Promise<string>;
+    print: (line: string) => void;
+    engineScript: (adapter: PluginAdapter) => string | null;
+    claudeEngine: (adapter: PluginAdapter) => string | null;
+    installEngine: (adapter: PluginAdapter) => {
+        version: string;
+        commit: string;
+    };
+};
+export type InitOptions = {
+    repos: string[];
+    yes: boolean;
+    json: boolean;
+    plugins: boolean | null;
+    local: Cli[] | null;
+    limits: {
+        max_jobs?: string;
+        max_run_minutes?: string;
+    };
+};
+export declare const NEEDS_HUMAN = 3;
+export declare function parseInitArgs(argv: string[]): InitOptions;
+type RepoEntry = {
+    alias: string;
+    path: string;
+};
+type TargetEntry = Record<string, unknown>;
+export declare function targetFor(cli: Cli, path: string, useEngine: boolean): TargetEntry;
+export declare function mergeConfig(existing: string | null, repos: RepoEntry[], targets: Record<string, TargetEntry>): {
+    toml: string;
+    addedRepos: string[];
+    addedTargets: string[];
+};
+export declare function runInit(env: InitEnv, options: InitOptions): Promise<number>;
+export declare function defaultInitEnv(configPath: string, json?: boolean): InitEnv & {
+    close: () => void;
+};
+export {};

package/dist/init.js

@@ -0,0 +1,322 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { ensureOutsrcHome, writeHomeFile } from "./fs-home.js";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { parse, stringify } from "smol-toml";
+import { z } from "zod";
+import { loadConfigFile } from "./config.js";
+import { changeSetting, listSettings, RISKS } from "./settings.js";
+import { createMailbox } from "./mailbox.js";
+import { checkPluginContract } from "./plugin-contract.js";
+import { installEngine, managedScript, readLock } from "./engines.js";
+import { isPluginAdapter, resolvePluginScript } from "./plugins.js";
+const CLIS = ["claude", "codex", "grok"];
+// Exit code for "stopped for a person": the caller should relay the needs_human events and rerun init.
+export const NEEDS_HUMAN = 3;
+export function parseInitArgs(argv) {
+    const options = { repos: [], yes: false, json: false, plugins: null, local: null, limits: {} };
+    for (let index = 0; index < argv.length; index++) {
+        const arg = argv[index];
+        const next = () => { const value = argv[++index]; if (value === undefined)
+            throw new Error(`${arg} needs a value`); return value; };
+        if (arg === "--repo")
+            options.repos.push(next());
+        else if (arg === "--yes" || arg === "-y")
+            options.yes = true;
+        else if (arg === "--json") {
+            options.json = true;
+            options.yes = true;
+        }
+        else if (arg === "--plugins")
+            options.plugins = true;
+        else if (arg === "--no-plugins")
+            options.plugins = false;
+        else if (arg === "--local")
+            options.local = z.array(z.enum(["claude", "codex", "grok"])).parse(next().split(",").filter(Boolean));
+        else if (arg === "--max-jobs")
+            options.limits.max_jobs = next();
+        else if (arg === "--max-run-minutes")
+            options.limits.max_run_minutes = next();
+        else
+            throw new Error(`unknown init option: ${arg}`);
+    }
+    return options;
+}
+export function targetFor(cli, path, useEngine) {
+    const description = {
+        claude: "Coding tasks and review through the Claude Code CLI.",
+        codex: "Coding tasks and code review through Codex, including its built-in and adversarial reviewers.",
+        grok: "Coding tasks and critique through Grok Build.",
+    }[cli];
+    const effort = cli === "grok" ? ["low", "medium", "high"] : cli === "codex" ? ["low", "medium", "high", "xhigh"] : ["low", "medium", "high", "xhigh", "max"];
+    // Engine targets carry no command: it resolves at load to the engine pinned in engines.lock.json.
+    const engine = useEngine && cli !== "claude" ? { adapter: `${cli}-plugin` } : { adapter: cli, command: path, args: [] };
+    return { ...engine, permissions: "auto", description, cost_note: `Uses this machine's ${cli} account.`, effort: { default: "medium", allowed: effort } };
+}
+const ExistingSchema = z.object({
+    repos: z.array(z.object({ alias: z.string(), path: z.string() }).passthrough()).default([]),
+    targets: z.record(z.string(), z.record(z.string(), z.unknown())).default({}),
+}).passthrough();
+// Existing repos and targets win; the wizard only adds what is missing, so reruns change nothing.
+export function mergeConfig(existing, repos, targets) {
+    const current = ExistingSchema.parse(existing ? parse(existing) : {});
+    const addedRepos = [];
+    const aliases = new Set(current.repos.map((repo) => repo.alias));
+    for (const repo of repos) {
+        if (current.repos.some((item) => resolve(item.path) === resolve(repo.path)))
+            continue;
+        let alias = repo.alias;
+        for (let n = 2; aliases.has(alias); n++)
+            alias = `${repo.alias}-${n}`;
+        aliases.add(alias);
+        current.repos.push({ alias, path: repo.path });
+        addedRepos.push(alias);
+    }
+    const addedTargets = Object.keys(targets).filter((name) => !(name in current.targets));
+    for (const name of addedTargets)
+        current.targets[name] = targets[name] ?? {};
+    return { toml: stringify(current), addedRepos, addedTargets };
+}
+function repoEntry(env, input) {
+    const top = env.run("git", ["-C", resolve(input), "rev-parse", "--show-toplevel"]);
+    if (top.status !== 0)
+        throw new Error(`not a git repository: ${input}`);
+    const path = top.stdout.trim();
+    const alias = basename(path).toLowerCase().replace(/[^a-z0-9._-]+/g, "-") || "repo";
+    return { alias, path };
+}
+const LocalCommands = {
+    claude: { registered: ["mcp", "get", "outsrc"], add: (server) => ["mcp", "add", "--scope", "user", "outsrc", "--", ...server] },
+    codex: { registered: ["mcp", "get", "outsrc"], add: (server) => ["mcp", "add", "outsrc", "--", ...server] },
+    grok: { registered: null, add: (server) => ["mcp", "add", "--scope", "user", "outsrc", "--", ...server] },
+};
+const LOGIN = {
+    claude: { check: ["auth", "status", "--json"], loggedIn: (r) => r.status === 0 && /"loggedIn":\s*true/.test(r.stdout), interactive: ["auth", "login"], headless: "claude auth login" },
+    codex: { check: ["login", "status"], loggedIn: (r) => r.status === 0, interactive: ["login"], headless: "codex login --device-auth" },
+    grok: { check: ["models"], loggedIn: (r) => r.status === 0, interactive: ["login"], headless: "grok login --device-auth" },
+};
+const PLUGINS = {
+    codex: { adapter: "codex-plugin", repo: "openai/codex-plugin-cc", adds: "Codex's own reviewer and adversarial review" },
+    grok: { adapter: "grok-plugin", repo: "xai-org/grok-build-plugin-cc", adds: "Grok's review and critique commands" },
+};
+export async function runInit(env, options) {
+    const say = env.print;
+    say("outsrc setup. It is safe to run again; existing settings are kept.\n");
+    const pending = [];
+    function needsHuman(step) {
+        pending.push(step);
+        env.emit({ event: "needs_human", ...step });
+        say(`  ACTION FOR A PERSON: ${step.instructions}`);
+    }
+    function finish(status, extra = {}) {
+        const code = status === 0 && pending.length ? NEEDS_HUMAN : status;
+        env.emit({ event: "done", status: code === 0 ? "ok" : code === NEEDS_HUMAN ? "needs_human" : "error", config: env.configPath, pending, ...extra });
+        if (code === NEEDS_HUMAN)
+            say("\nFinish the actions above, then run outsrc init again. It picks up where it stopped.");
+        return code;
+    }
+    const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+    if (!((major === 22 && minor >= 12) || major === 24 || major >= 26)) {
+        say(`Node ${process.version} is not supported. Use 22.12+, 24 or 26+.`);
+        return finish(1, { error: "unsupported node" });
+    }
+    if (!env.which("git")) {
+        say("git is required.");
+        return finish(1, { error: "git not found" });
+    }
+    const found = Object.fromEntries(CLIS.map((cli) => [cli, env.which(cli)]));
+    say("Agent CLIs on this machine:");
+    for (const cli of CLIS)
+        say(`  ${cli}: ${found[cli] ?? "not found"}`);
+    if (!CLIS.some((cli) => found[cli])) {
+        say("\nInstall at least one of claude, codex or grok, log in, then run outsrc init again.");
+        return finish(1, { error: "no agent CLI found" });
+    }
+    for (const cli of CLIS) {
+        if (!found[cli])
+            continue;
+        const login = LOGIN[cli];
+        if (login.loggedIn(env.run(cli, login.check)))
+            continue;
+        if (!options.yes && await env.confirm(`  ${cli} is not logged in. Log in now? This opens a browser.`, true)) {
+            env.runInteractive(cli, login.interactive);
+            if (login.loggedIn(env.run(cli, login.check)))
+                continue;
+        }
+        needsHuman({ step: "login", cli, command: login.headless, instructions: `Log in to ${cli}: run \`${login.headless}\` on this machine and finish the sign-in.` });
+    }
+    const engines = new Set();
+    for (const cli of ["codex", "grok"]) {
+        const plugin = PLUGINS[cli];
+        if (!found[cli])
+            continue;
+        if (env.engineScript(plugin.adapter)) {
+            engines.add(cli);
+            continue;
+        }
+        const wanted = options.plugins ?? (options.yes || await env.confirm(`  Download the ${plugin.repo} engine into outsrc? It adds ${plugin.adds}. Claude Code is not needed.`, true));
+        const fallback = env.claudeEngine(plugin.adapter) ? "using Claude Code's copy of the plugin, which is not pinned" : "calling the CLI directly";
+        if (!wanted) {
+            say(`  ${cli}: ${fallback}`);
+        }
+        else {
+            try {
+                const pinned = env.installEngine(plugin.adapter);
+                engines.add(cli);
+                say(`  ${cli}: downloaded ${plugin.repo} ${pinned.version} (${pinned.commit.slice(0, 7)})`);
+                continue;
+            }
+            catch (error) {
+                say(`  ${cli}: could not download ${plugin.repo}, ${fallback}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (env.claudeEngine(plugin.adapter))
+            engines.add(cli);
+    }
+    const targets = {};
+    for (const cli of CLIS) {
+        const path = found[cli];
+        if (path)
+            targets[cli] = targetFor(cli, path, engines.has(cli));
+    }
+    say("\nRepositories agents may start work in. outsrc refuses any other repository, but the agent CLIs are not sandboxed to these folders.");
+    const repos = [];
+    for (const path of options.repos)
+        repos.push(repoEntry(env, path));
+    if (!options.yes) {
+        for (;;) {
+            const answer = (await env.ask("  Repository path (blank when done): ")).trim();
+            if (!answer)
+                break;
+            try {
+                const entry = repoEntry(env, answer);
+                repos.push(entry);
+                say(`  added ${entry.alias} -> ${entry.path}`);
+            }
+            catch (error) {
+                say(`  ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    ensureOutsrcHome(dirname(env.configPath));
+    const merged = mergeConfig(existsSync(env.configPath) ? readFileSync(env.configPath, "utf8") : null, repos, targets);
+    writeHomeFile(env.configPath, merged.toml);
+    say(`\nWrote ${env.configPath}. New repositories: ${merged.addedRepos.join(", ") || "none"}. New targets: ${merged.addedTargets.join(", ") || "none"}.`);
+    const LIMIT_QUESTIONS = {
+        max_jobs: "Most jobs working at once (a number, or unlimited)",
+        max_run_minutes: "Longest a run may take, in minutes (a number, or unlimited)",
+    };
+    for (const name of ["max_jobs", "max_run_minutes"]) {
+        let answer = options.limits[name];
+        if (answer === undefined && !options.yes) {
+            const current = listSettings(env.configPath).limits[name];
+            answer = (await env.ask(`  ${LIMIT_QUESTIONS[name]} [${current}]: `)).trim() || undefined;
+            if (answer === "unlimited" && !await env.confirm(`  ${RISKS[`limits.${name}`]} Use unlimited?`, false))
+                answer = undefined;
+        }
+        if (answer === undefined)
+            continue;
+        const change = changeSetting(env.configPath, `limits.${name}`, answer);
+        if (!change.ok)
+            throw new Error(change.error);
+        say(`  limits.${name} = ${answer}${change.warning ? `. ${change.warning}` : ""}`);
+    }
+    const config = loadConfigFile(env.configPath);
+    const settings = listSettings(env.configPath);
+    env.emit({ event: "settings", limits: settings.limits, repos: settings.repos.map((repo) => repo.alias), targets: Object.keys(settings.targets),
+        instructions: "Review these with the owner: run outsrc config for every setting and its meaning, and outsrc config set <key> <value> for each change they ask for." });
+    say(`\nLimits: ${settings.limits.max_jobs} jobs at once, ${settings.limits.max_run_minutes} minutes per run. See every setting with outsrc config.`);
+    if (config.repos.length === 0)
+        say("No repositories are configured yet. Run outsrc init again with --repo <path>.");
+    const box = createMailbox({ home: dirname(env.configPath), config });
+    for (const target of box.listTargets().targets) {
+        const warning = "warning" in target ? ` (${String(target.warning)})` : "";
+        say(`  target ${target.name}: ${target.available ? "available" : "NOT available"}${warning}`);
+    }
+    for (const target of Object.values(config.targets)) {
+        if (target.adapter && isPluginAdapter(target.adapter) && target.command) {
+            const report = checkPluginContract(target.adapter, target.command);
+            if (report.status === "broken")
+                say(`  ${target.adapter} ${report.version ?? ""} is incompatible: ${report.problems.join("; ")}`);
+        }
+    }
+    const ephemeral = env.serverCommand.some((part) => part.includes("/_npx/"));
+    if (ephemeral) {
+        say("\nYou ran outsrc through npx, whose files live in a temporary cache. Install it with `npm i -g outsrc` and run `outsrc init` again to connect agents to a stable copy.");
+        return finish(0, { error: "npx copy not registered" });
+    }
+    say("\nLocal agents can call outsrc as an MCP server to hand work to the other CLIs.");
+    for (const cli of CLIS) {
+        if (!found[cli])
+            continue;
+        const wanted = options.local ? options.local.includes(cli) : options.yes ? false : await env.confirm(`  Add outsrc to ${cli}?`, true);
+        if (!wanted)
+            continue;
+        const commands = LocalCommands[cli];
+        if (commands.registered && env.run(cli, commands.registered).status === 0) {
+            say(`  ${cli}: already has outsrc`);
+            continue;
+        }
+        const added = env.run(cli, commands.add([...env.serverCommand, "--caller", cli]));
+        say(added.status === 0 ? `  ${cli}: added outsrc` : `  ${cli}: could not add outsrc: ${added.stderr.trim() || added.stdout.trim()}`);
+    }
+    say("\nDone. Run `outsrc doctor` any time to recheck.");
+    return finish(0);
+}
+function lookup(command) {
+    for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+        const candidate = join(directory, command);
+        // Keep the PATH entry, not its target: ~/.local/bin/claude points at a versioned binary that updates replace.
+        if (directory && existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function defaultInitEnv(configPath, json = false) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const server = join(dirname(fileURLToPath(import.meta.url)), "server.js");
+    return {
+        configPath,
+        serverCommand: [process.execPath, existsSync(server) ? realpathSync(server) : server],
+        which: lookup,
+        run: (command, args) => {
+            const result = spawnSync(command, args, { encoding: "utf8", timeout: 120_000 });
+            return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? String(result.error ?? "") };
+        },
+        runInteractive: (command, args) => spawnSync(command, args, { stdio: "inherit" }).status,
+        runStreaming: (command, args, onLine) => new Promise((done) => {
+            const child = spawn(command, args, { stdio: ["inherit", "pipe", "inherit"] });
+            let buffer = "";
+            child.stdout.on("data", (chunk) => {
+                buffer += chunk.toString("utf8");
+                for (let index = buffer.indexOf("\n"); index >= 0; index = buffer.indexOf("\n")) {
+                    onLine(buffer.slice(0, index));
+                    buffer = buffer.slice(index + 1);
+                }
+            });
+            child.once("error", () => done(null));
+            child.once("close", (code) => { if (buffer)
+                onLine(buffer); done(code); });
+        }),
+        emit: (event) => { if (json)
+            process.stdout.write(`${JSON.stringify(event)}\n`); },
+        confirm: async (question, fallback) => {
+            const answer = (await rl.question(`${question} ${fallback ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase();
+            return answer ? answer.startsWith("y") : fallback;
+        },
+        ask: (question) => rl.question(question),
+        print: (line) => (json ? process.stderr : process.stdout).write(`${line}\n`),
+        engineScript: (adapter) => managedScript(dirname(configPath), adapter),
+        claudeEngine: (adapter) => resolvePluginScript(adapter),
+        installEngine: (adapter) => {
+            const entry = readLock()[adapter];
+            if (!entry)
+                throw new Error(`engines.lock.json has no ${adapter} entry`);
+            installEngine(dirname(configPath), adapter, entry);
+            return { version: entry.version, commit: entry.commit };
+        },
+        close: () => rl.close(),
+    };
+}

package/dist/job.d.ts

@@ -0,0 +1,19 @@
+import type { MailboxContext } from "./types.js";
+export type ProcessRecord = {
+    pid: number;
+    pgid: number;
+    startedAt: string;
+};
+export declare const DEFAULT_WRAPPER: string;
+export declare const JOB_MARKER = "OUTSRC_JOB";
+export declare function jobEnv(extra?: Record<string, string>): NodeJS.ProcessEnv;
+export declare function commandExists(command: string): boolean;
+export declare function captureProcess(pid: number): ProcessRecord | null;
+export declare function processIdentity(record: ProcessRecord): "match" | "mismatch" | "unknown";
+export declare function sameProcess(record: ProcessRecord): boolean;
+export declare function startWrapper(input: {
+    ctx: MailboxContext;
+    specFile: string;
+}): Promise<ProcessRecord | null>;
+export declare function pidAlive(pid: number): boolean;
+export declare function stopOwnedProcess(record: ProcessRecord): boolean;

package/dist/job.js

@@ -0,0 +1,112 @@
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const source = fileURLToPath(import.meta.url).endsWith(".ts");
+const here = dirname(fileURLToPath(import.meta.url));
+export const DEFAULT_WRAPPER = join(here, source ? "wrapper.ts" : "wrapper.js");
+const BASE_ENV = ["PATH", "HOME", "USER", "LANG", "TMPDIR", "TERM"];
+// Set in every job's environment. An outsrc server started by an agent inside a job sees it and refuses to send,
+// so a delegated agent cannot delegate onward.
+export const JOB_MARKER = "OUTSRC_JOB";
+export function jobEnv(extra = {}) {
+    const env = {};
+    for (const key of BASE_ENV) {
+        const value = process.env[key];
+        if (value)
+            env[key] = value;
+    }
+    return { ...env, [JOB_MARKER]: "1", ...extra };
+}
+export function commandExists(command) {
+    if (!command)
+        return false;
+    if (command.includes("/") || command.startsWith("."))
+        return existsSync(command);
+    return (process.env.PATH ?? "").split(":").some((dir) => existsSync(join(dir, command)));
+}
+// lstart is formatted by the caller's locale and time zone; pin both so the recording and checking processes agree.
+function startTime(pid) {
+    return execFileSync("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8", env: { ...process.env, LC_ALL: "C", TZ: "UTC0" } }).trim();
+}
+export function captureProcess(pid) {
+    if (!Number.isInteger(pid) || pid < 2)
+        return null;
+    try {
+        const startedAt = startTime(pid);
+        if (!startedAt)
+            return null;
+        return { pid, pgid: pid, startedAt };
+    }
+    catch {
+        return null;
+    }
+}
+export function processIdentity(record) {
+    if (!Number.isInteger(record.pid) || record.pid < 2 || record.pgid !== record.pid || record.startedAt.length === 0)
+        return "mismatch";
+    try {
+        const startedAt = startTime(record.pid);
+        if (!startedAt)
+            return "unknown";
+        return startedAt === record.startedAt ? "match" : "mismatch";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export function sameProcess(record) {
+    return processIdentity(record) === "match";
+}
+export async function startWrapper(input) {
+    const node = input.ctx.nodeExecutable ?? process.execPath;
+    const wrapper = input.ctx.wrapperCommand ?? [node, ...(source ? ["--import", import.meta.resolve("tsx")] : []), DEFAULT_WRAPPER];
+    const command = wrapper[0];
+    if (!command)
+        throw new Error("wrapper command is empty");
+    const env = jobEnv();
+    const child = spawn(command, [...wrapper.slice(1), "--spec", input.specFile], {
+        detached: true,
+        stdio: "ignore",
+        env,
+    });
+    await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("spawn", resolve);
+    });
+    child.unref();
+    if (child.pid === undefined)
+        throw new Error("failed to spawn wrapper");
+    return captureProcess(child.pid);
+}
+export function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function stopOwnedProcess(record) {
+    if (!sameProcess(record))
+        return false;
+    try {
+        process.kill(-record.pgid, "SIGTERM");
+    }
+    catch {
+        return false;
+    }
+    const killer = setTimeout(() => {
+        if (!sameProcess(record))
+            return;
+        try {
+            process.kill(-record.pgid, "SIGKILL");
+        }
+        catch {
+            return;
+        }
+    }, 2000);
+    killer.unref();
+    return true;
+}

package/dist/limits.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_LIMITS: {
+    readonly max_jobs: 4;
+    readonly max_run_minutes: 120;
+};
+export type Limits = {
+    maxJobs: number | null;
+    maxRunMinutes: number | null;
+};
+export declare function resolveLimits(limits: Limits | undefined): Limits;
+export declare const MAX_LOG_READ_BYTES = 8192;
+export declare const MAX_LOG_BYTES = 1048576;
+export declare const MAX_RUN_MS: number;
+export declare const LOG_TRUNCATED = "\n[outsrc log truncated]\n";

package/dist/limits.js

@@ -0,0 +1,10 @@
+// Owner-configurable in config.toml [limits]; "unlimited" is stored as null.
+export const DEFAULT_LIMITS = { max_jobs: 4, max_run_minutes: 120 };
+export function resolveLimits(limits) {
+    return limits ?? { maxJobs: DEFAULT_LIMITS.max_jobs, maxRunMinutes: DEFAULT_LIMITS.max_run_minutes };
+}
+export const MAX_LOG_READ_BYTES = 8192;
+export const MAX_LOG_BYTES = 1_048_576;
+// Deadline for a run whose spec predates configurable limits.
+export const MAX_RUN_MS = DEFAULT_LIMITS.max_run_minutes * 60 * 1000;
+export const LOG_TRUNCATED = "\n[outsrc log truncated]\n";

package/dist/mailbox.d.ts

@@ -0,0 +1,122 @@
+import { type InboxResult, type MailboxContext, type SendInput, type SendResult, type ThreadId } from "./types.js";
+export declare function requestFileName(caller: string | undefined, requestId: string): string;
+export declare function createMailbox(ctx: MailboxContext): {
+    listRepos: () => {
+        repos: {
+            alias: string;
+            path: string;
+        }[];
+    };
+    listTargets: () => {
+        targets: {
+            name: string;
+            adapter: import("./adapters.js").Adapter;
+            available: boolean;
+            models: {
+                default: string;
+                allowed: string[];
+            } | null;
+            effort: {
+                default: string;
+                allowed: string[];
+            } | null;
+            description: string;
+            cost_note: string;
+            resume: boolean;
+        }[];
+    };
+    send: (input: SendInput) => Promise<SendResult>;
+    inbox: (threadId: string) => InboxResult;
+    threads: () => {
+        threads: {
+            thread_id: ThreadId;
+            repo: import("./types.js").Alias;
+            target: import("./types.js").TargetName;
+            kind: import("./types.js").TaskKind;
+            status: "cancelled" | "failed" | "needs_input" | "succeeded" | "working";
+            discarded: boolean;
+            created_at: string;
+            run_id: string;
+            run_count: number;
+            message: string;
+        }[];
+    };
+    discard: (threadId: string) => {
+        ok: boolean;
+        discarded: boolean;
+        thread_id: ThreadId;
+        error?: never;
+    } | {
+        discarded?: never;
+        thread_id?: never;
+        ok: boolean;
+        error: string;
+    };
+    history(threadId: string): {
+        error?: never;
+        ok: boolean;
+        thread_id: ThreadId;
+        runs: {
+            run_id: import("./types.js").RunId;
+            request_id: string | null;
+            created_at: string;
+            message: string;
+            status: string;
+            session_id: string | null;
+            final_message: string | null;
+            findings: {
+                priority: "P0" | "P1" | "P2" | "P3";
+                title: string;
+                body: string;
+                path: string | null;
+                line: number | null;
+            }[];
+            exit_code: number | null;
+        }[];
+    } | {
+        thread_id?: never;
+        runs?: never;
+        ok: boolean;
+        error: string;
+    };
+    log(input: {
+        thread_id: string;
+        run_id?: string;
+        offset?: number;
+        limit?: number;
+    }): {
+        error?: never;
+        ok: boolean;
+        text: string;
+    } | {
+        text?: never;
+        ok: boolean;
+        error: string;
+    };
+    diff(input: {
+        thread_id: string;
+        limit?: number;
+    }): {
+        patch: string;
+        stat: string;
+        truncated: boolean;
+        error?: never;
+        ok: boolean;
+    } | {
+        ok: boolean;
+        error: string;
+    };
+    stop(threadId: string): {
+        error?: never;
+        ok: boolean;
+        stopped: boolean;
+    } | {
+        stopped?: never;
+        ok: boolean;
+        error: string;
+    };
+    prune(): {
+        removed: string[];
+    };
+};
+export type Mailbox = ReturnType<typeof createMailbox>;