codex-toys 0.135.0

package/dist/cli/index.js

@@ -0,0 +1,979 @@
+#!/usr/bin/env node
+import { APP_CALL_METHOD, TOYBOX_INITIALIZE_METHOD, } from "../toybox/index.js";
+import { COMMON_APP_SERVER_ACTIONS, COMMON_TOYBOX_METHODS, } from "./actions.js";
+import { cleanupActionsCodexHome, prepareActionsCodexAuth, } from "../actions.js";
+import { parseArgs, } from "./args.js";
+import { collectFetchInfo, formatFetchInfo, } from "./fetch.js";
+import { applyMemoryTransplant, formatMemoryTransplantPlan, } from "./memories.js";
+import { applyPackAdd, collectPackDoctor, formatPackAddPlan, formatPackDoctor, formatPackInspection, formatPackList, inspectPackSource, listInstalledPacks, } from "./pack.js";
+import { formatRemoteTurnStartResult, startRemoteTurn, } from "./remote-control.js";
+import { collectRemotePreflight, formatRemotePreflight, } from "./remote-preflight.js";
+import { createTurnAutomationHost, formatTurnAutomationList, formatTurnAutomationRun, listTurnAutomations, resolveTurnAutomationTarget, runTurnAutomationScript, } from "./turn-automation.js";
+import { createLocalToyboxTransport, createSshToyboxTransport, hasSshRemote, withSshRemoteToyboxTransport, } from "./remote-provider.js";
+import { REMOTE_AUTOMATION_LIST_METHOD, REMOTE_AUTOMATION_RUN_METHOD, } from "./remote-automation.js";
+import { WORKSPACE_FUNCTIONS_CALL_METHOD, WORKSPACE_FUNCTIONS_DESCRIBE_METHOD, WORKSPACE_FUNCTIONS_LIST_METHOD, } from "../functions.js";
+import { serveToybox } from "./toybox.js";
+import { formatThreadRolloutInspection, formatThreadRolloutInstallation, formatThreadRolloutLocation, formatThreadRolloutTransplant, installThreadRollout, inspectThreadRollout, locateThreadRollout, transplantThreadRollout, } from "../threads.js";
+import { collectWorkspaceDoctorInfo, commitActionsWorkspaceState, createWorkspaceContext, formatWorkspaceDoctorInfo, runWorkspaceTaskById, scaffoldActionsWorkspace, tickWorkspace, } from "./workspace-autonomy.js";
+import { formatWorkspaceDelegationListResult, formatWorkspaceDelegationStartResult, startWorkspaceDelegationWithRequest, } from "./workspace-delegation.js";
+import { serveCodexToysMcp } from "./mcp.js";
+import { parseJsonParamsText, readJsonFile } from "./json.js";
+await main().catch((error) => {
+    process.stderr.write(`${errorMessage(error)}\n`);
+    process.exitCode = 1;
+});
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2), process.env);
+    if (parsed.type === "help") {
+        write(helpText());
+        return;
+    }
+    if (parsed.type === "mcp-serve") {
+        serveCodexToysMcp({
+            timeoutMs: parsed.timeoutMs,
+        });
+        return;
+    }
+    if (parsed.type === "fetch") {
+        const info = await collectFetchInfo({
+            appUrl: parsed.appUrl,
+            workspaceUrl: parsed.workspaceUrl,
+            cwd: parsed.sshTarget ? parsed.cwd : undefined,
+            toybox: await collectToyboxInfo(parsed),
+        });
+        write(parsed.json
+            ? `${JSON.stringify(info, null, 2)}\n`
+            : formatFetchInfo(info, { color: parsed.color }));
+        return;
+    }
+    if (parsed.type === "remote-preflight") {
+        const result = await collectRemotePreflight(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(result, null, parsed.pretty ? 2 : 0)}\n`
+            : formatRemotePreflight(result));
+        if (!result.ok) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (parsed.type === "toybox-serve") {
+        await serveToybox({
+            cwd: parsed.cwd,
+            timeoutMs: parsed.timeoutMs,
+            codexCommand: parsed.remoteCodexCommand,
+            codexArgs: parsed.remoteCodexArgs,
+        });
+        return;
+    }
+    if (parsed.type === "automation-run") {
+        validateAutomationTurnOptions(parsed);
+        if (hasSshRemote(parsed)) {
+            const run = await runRemoteTurnAutomationForCli(parsed);
+            write(parsed.json
+                ? `${JSON.stringify(run, null, parsed.pretty ? 2 : 0)}\n`
+                : formatTurnAutomationRun(run));
+            return;
+        }
+        const event = parsed.eventPath
+            ? await readJsonFile(parsed.eventPath)
+            : undefined;
+        const target = await resolveTurnAutomationTarget(parsed.target, {
+            cwd: parsed.workspaceRoot,
+        });
+        const prompt = parsed.prompt ?? target.prompt;
+        const cwd = parsed.cwd ?? target.cwd;
+        const run = await runTurnAutomationForCli(target, {
+            event,
+            prompt,
+            cwd,
+            via: parsed.via,
+            appUrl: parsed.appUrl,
+            workspaceUrl: parsed.workspaceUrl,
+            timeoutMs: parsed.timeoutMs,
+            sandbox: parsed.sandbox,
+            approvalPolicy: parsed.approvalPolicy,
+            permissions: parsed.permissions,
+            model: parsed.model,
+            sshTarget: parsed.sshTarget,
+            remotePathPrepend: parsed.remotePathPrepend,
+            toyboxCommand: parsed.toyboxCommand,
+            remoteCodexCommand: parsed.remoteCodexCommand,
+            remoteCodexArgs: parsed.remoteCodexArgs,
+        });
+        write(parsed.json
+            ? `${JSON.stringify(run, null, parsed.pretty ? 2 : 0)}\n`
+            : formatTurnAutomationRun(run));
+        return;
+    }
+    if (parsed.type === "automation-list") {
+        const automations = hasSshRemote(parsed)
+            ? await listRemoteTurnAutomationsForCli(parsed)
+            : await listTurnAutomations({ cwd: parsed.workspaceRoot });
+        write(parsed.json
+            ? `${JSON.stringify({ automations }, null, parsed.pretty ? 2 : 0)}\n`
+            : formatTurnAutomationList(automations));
+        return;
+    }
+    if (parsed.type === "app-actions") {
+        write(`${COMMON_APP_SERVER_ACTIONS.join("\n")}\n`);
+        return;
+    }
+    if (parsed.type === "app-call") {
+        writeJson(await callAppServer(parsed.method, await readParams(parsed.paramsText, parsed.paramsFile), parsed), parsed.pretty);
+        return;
+    }
+    if (parsed.type === "functions-list") {
+        const response = await callToybox(WORKSPACE_FUNCTIONS_LIST_METHOD, {}, parsed);
+        write(parsed.json
+            ? `${JSON.stringify(response, null, parsed.pretty ? 2 : 0)}\n`
+            : formatFunctionsList(response.functions));
+        return;
+    }
+    if (parsed.type === "functions-describe") {
+        const response = await callToybox(WORKSPACE_FUNCTIONS_DESCRIBE_METHOD, { name: parsed.name }, parsed);
+        write(parsed.json
+            ? `${JSON.stringify(response, null, parsed.pretty ? 2 : 0)}\n`
+            : formatFunctionDescription(response.function));
+        return;
+    }
+    if (parsed.type === "functions-call") {
+        const response = await callToybox(WORKSPACE_FUNCTIONS_CALL_METHOD, {
+            name: parsed.name,
+            params: await readParams(parsed.paramsText, parsed.paramsFile),
+        }, parsed);
+        write(parsed.json
+            ? `${JSON.stringify(response, null, parsed.pretty ? 2 : 0)}\n`
+            : `${JSON.stringify(response.result, null, 2)}\n`);
+        return;
+    }
+    if (parsed.type === "turn-run") {
+        const result = await startRemoteTurn({
+            prompt: parsed.prompt,
+            threadId: parsed.threadId,
+            cwd: parsed.cwd,
+            via: "workspace",
+            appUrl: parsed.appUrl,
+            workspaceUrl: parsed.workspaceUrl,
+            timeoutMs: parsed.timeoutMs,
+            wait: parsed.wait,
+            sandbox: parsed.sandbox,
+            approvalPolicy: parsed.approvalPolicy,
+            permissions: parsed.permissions,
+            model: parsed.model,
+            sshTarget: parsed.sshTarget,
+            remotePathPrepend: parsed.remotePathPrepend,
+            toyboxCommand: parsed.toyboxCommand,
+            remoteCodexCommand: parsed.remoteCodexCommand,
+            remoteCodexArgs: parsed.remoteCodexArgs,
+        });
+        write(parsed.json
+            ? `${JSON.stringify({
+                threadId: result.threadId,
+                turnId: result.turnId,
+                status: result.status,
+                cwd: result.cwd ?? parsed.cwd ?? null,
+                finalMessage: result.finalMessage,
+                error: result.error,
+            }, null, parsed.pretty ? 2 : 0)}\n`
+            : formatRemoteTurnStartResult(result));
+        if (parsed.wait && (result.status === "failed" || result.status === "timed_out")) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (parsed.type === "workspace-methods") {
+        const initialized = await initializeToybox(parsed);
+        writeJson({
+            advertised: initialized.capabilities.toyboxMethods,
+            common: COMMON_TOYBOX_METHODS,
+        }, parsed.pretty);
+        return;
+    }
+    if (parsed.type === "workspace-delegate-list") {
+        const response = await callToybox("delegation.list", { includeTargets: true }, parsed);
+        write(parsed.json
+            ? `${JSON.stringify(response, null, parsed.pretty ? 2 : 0)}\n`
+            : formatWorkspaceDelegationListResult(response));
+        return;
+    }
+    if (parsed.type === "workspace-delegate-start") {
+        validateAutomationTurnOptions(parsed);
+        const result = await withWorkspaceTransport(parsed, async (transport) => {
+            await initialize(transport);
+            return await startWorkspaceDelegationWithRequest(async (method, params) => await transport.request(method, params), {
+                cwd: parsed.targetCwd,
+                prompt: parsed.prompt,
+                title: parsed.title,
+                groupId: parsed.groupId,
+                returnMode: parsed.returnMode,
+                wait: parsed.wait,
+                timeoutMs: parsed.timeoutMs,
+                allowAbsoluteCwd: parsed.allowAbsoluteCwd,
+                model: parsed.model,
+                sandbox: parsed.sandbox,
+                approvalPolicy: parsed.approvalPolicy,
+                permissions: parsed.permissions,
+            });
+        });
+        write(parsed.json
+            ? `${JSON.stringify(result, null, parsed.pretty ? 2 : 0)}\n`
+            : formatWorkspaceDelegationStartResult(result));
+        if (result.wait?.status === "failed") {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (parsed.type === "workspace-doctor") {
+        const context = await createWorkspaceContext({
+            workspaceRoot: parsed.workspaceRoot,
+            mode: parsed.mode,
+        });
+        const info = await collectWorkspaceDoctorInfo(context);
+        const toybox = await collectToyboxInfo({
+            appUrl: parsed.appUrl,
+            workspaceUrl: parsed.workspaceUrl,
+            timeoutMs: parsed.timeoutMs,
+            sshTarget: parsed.sshTarget,
+            cwd: parsed.cwd,
+            remotePathPrepend: parsed.remotePathPrepend,
+            toyboxCommand: parsed.toyboxCommand,
+            remoteCodexCommand: parsed.remoteCodexCommand,
+            remoteCodexArgs: parsed.remoteCodexArgs,
+        });
+        const result = { ...info, toybox };
+        write(parsed.json
+            ? `${JSON.stringify(result, null, 2)}\n`
+            : `${formatWorkspaceDoctorInfo(info)}toybox             ${toyboxLabelForDoctor(toybox)}\n`);
+        return;
+    }
+    if (parsed.type === "workspace-tick") {
+        const context = await createWorkspaceContext({
+            workspaceRoot: parsed.workspaceRoot,
+            mode: parsed.mode,
+        });
+        const result = await tickWorkspace(context, {
+            callToybox: async (method, params) => await callToybox(method, params, parsed),
+            automationCwd: parsed.cwd,
+        });
+        writeJson({
+            ...result,
+            actionsCommit: await commitActionsWorkspaceState(context),
+        }, parsed.pretty);
+        return;
+    }
+    if (parsed.type === "workspace-run") {
+        const context = await createWorkspaceContext({
+            workspaceRoot: parsed.workspaceRoot,
+            mode: parsed.mode,
+        });
+        const run = await runWorkspaceTaskById(context, parsed.taskId, {
+            callToybox: async (method, params) => await callToybox(method, params, parsed),
+            automationCwd: parsed.cwd,
+        });
+        writeJson({
+            run,
+            actionsCommit: await commitActionsWorkspaceState(context, {
+                message: `Update Codex workspace state for ${parsed.taskId}`,
+            }),
+        }, parsed.pretty);
+        return;
+    }
+    if (parsed.type === "workspace-init-actions") {
+        writeJson(await scaffoldActionsWorkspace({
+            workspaceRoot: parsed.workspaceRoot,
+            forgejo: parsed.forgejo,
+            github: parsed.github,
+            overwrite: parsed.overwrite,
+        }), parsed.pretty);
+        return;
+    }
+    if (parsed.type === "workspace-call") {
+        writeJson(await callToybox(parsed.method, await readParams(parsed.paramsText, parsed.paramsFile), parsed), parsed.pretty);
+        return;
+    }
+    if (parsed.type === "workspace-app-call") {
+        writeJson(await callToybox(APP_CALL_METHOD, {
+            method: parsed.method,
+            params: await readParams(parsed.paramsText, parsed.paramsFile),
+        }, parsed), parsed.pretty);
+        return;
+    }
+    if (parsed.type === "actions-prepare-auth") {
+        const context = await createWorkspaceContext({
+            workspaceRoot: parsed.workspaceRoot,
+            mode: "actions",
+        });
+        writeJson(await prepareActionsCodexAuth({
+            workspaceRoot: context.repoRoot,
+            env: process.env,
+        }), parsed.pretty);
+        return;
+    }
+    if (parsed.type === "actions-cleanup") {
+        const context = await createWorkspaceContext({
+            workspaceRoot: parsed.workspaceRoot,
+            mode: "actions",
+        });
+        writeJson(await cleanupActionsCodexHome({
+            workspaceRoot: context.repoRoot,
+        }), parsed.pretty);
+        return;
+    }
+    if (parsed.type === "memories-transplant") {
+        const plan = await applyMemoryTransplant(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(plan, null, 2)}\n`
+            : formatMemoryTransplantPlan(plan));
+        return;
+    }
+    if (parsed.type === "threads-locate") {
+        const location = await locateThreadRollout(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(location, null, 2)}\n`
+            : formatThreadRolloutLocation(location));
+        return;
+    }
+    if (parsed.type === "threads-inspect") {
+        const result = await inspectThreadRollout(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(result, null, 2)}\n`
+            : formatThreadRolloutInspection(result));
+        return;
+    }
+    if (parsed.type === "threads-install-rollout") {
+        const result = await installThreadRollout(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(result, null, 2)}\n`
+            : formatThreadRolloutInstallation(result));
+        return;
+    }
+    if (parsed.type === "threads-transplant") {
+        const result = await transplantThreadRollout(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(result, null, 2)}\n`
+            : formatThreadRolloutTransplant(result));
+        return;
+    }
+    if (parsed.type === "pack-inspect") {
+        const inspection = await inspectPackSource(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(inspection, null, 2)}\n`
+            : formatPackInspection(inspection));
+        return;
+    }
+    if (parsed.type === "pack-add") {
+        const plan = await applyPackAdd(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(plan, null, 2)}\n`
+            : formatPackAddPlan(plan));
+        return;
+    }
+    if (parsed.type === "pack-doctor") {
+        const result = await collectPackDoctor(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(result, null, 2)}\n`
+            : formatPackDoctor(result));
+        return;
+    }
+    if (parsed.type === "pack-list") {
+        const result = await listInstalledPacks(parsed);
+        write(parsed.json
+            ? `${JSON.stringify(result, null, 2)}\n`
+            : formatPackList(result));
+        return;
+    }
+}
+function toyboxLabelForDoctor(toybox) {
+    if (toybox.status === "connected") {
+        return toybox.url ? `${toybox.transport} connected (${toybox.url})` : `${toybox.transport} connected`;
+    }
+    return toybox.error ? `unavailable (${toybox.error})` : "unavailable";
+}
+async function callAppServer(method, params, options) {
+    return await callToybox(APP_CALL_METHOD, { method, params }, options);
+}
+async function listRemoteTurnAutomationsForCli(options) {
+    return await withSshRemoteToyboxTransport(options, async (transport) => {
+        await initialize(transport);
+        const response = await transport.request(REMOTE_AUTOMATION_LIST_METHOD, {
+            workspaceRoot: options.workspaceRoot,
+            cwd: options.cwd,
+        });
+        return response.automations;
+    });
+}
+async function runRemoteTurnAutomationForCli(options) {
+    return await withSshRemoteToyboxTransport(options, async (transport) => {
+        await initialize(transport);
+        return await transport.request(REMOTE_AUTOMATION_RUN_METHOD, {
+            target: options.target,
+            eventPath: options.eventPath,
+            prompt: options.prompt,
+            workspaceRoot: options.workspaceRoot,
+            cwd: options.cwd,
+            via: options.via,
+            timeoutMs: options.timeoutMs,
+            sandbox: options.sandbox,
+            approvalPolicy: options.approvalPolicy,
+            permissions: options.permissions,
+            model: options.model,
+        });
+    });
+}
+function validateAutomationTurnOptions(options) {
+    if (options.sandbox && options.permissions) {
+        throw new Error("--sandbox cannot be combined with --permissions");
+    }
+}
+function formatFunctionsList(functions) {
+    if (functions.length === 0) {
+        return "No workspace functions found.\n";
+    }
+    return `${functions.map((fn) => {
+        const suffix = fn.description ? ` - ${fn.description}` : "";
+        return `${fn.name} [${fn.sideEffects}]${suffix}`;
+    }).join("\n")}\n`;
+}
+function formatFunctionDescription(fn) {
+    return `${JSON.stringify(fn, null, 2)}\n`;
+}
+async function runTurnAutomationForCli(target, options) {
+    const host = createCliTurnAutomationHost({
+        ...options,
+        defaults: {
+            prompt: options.prompt,
+            cwd: options.cwd,
+            skills: target.skills,
+            sandbox: options.sandbox,
+            approvalPolicy: options.approvalPolicy,
+            permissions: options.permissions,
+            model: options.model,
+        },
+    });
+    try {
+        return await runTurnAutomationScript({
+            scriptPath: target.scriptPath,
+            automation: target.automation,
+            event: options.event,
+            prompt: options.prompt,
+            cwd: options.cwd,
+            timeoutMs: options.timeoutMs,
+            host: host.handler,
+        });
+    }
+    finally {
+        host.close();
+    }
+}
+function createCliTurnAutomationHost(options) {
+    if (options.via === "workspace") {
+        const requester = createLazyWorkspaceRequester({
+            ...options,
+            url: options.workspaceUrl,
+        });
+        return {
+            handler: createTurnAutomationHost({
+                via: "workspace",
+                appRequest: requester.appRequest,
+                workspaceRequest: requester.workspaceRequest,
+                defaults: options.defaults,
+            }),
+            close: requester.close,
+        };
+    }
+    const requester = createLazyAppServerRequester({
+        ...options,
+        url: options.appUrl,
+    });
+    return {
+        handler: createTurnAutomationHost({
+            via: "app-server",
+            appRequest: requester.request,
+            defaults: options.defaults,
+        }),
+        close: requester.close,
+    };
+}
+function createLazyAppServerRequester(options) {
+    const requester = createLazyWorkspaceRequester(options);
+    return {
+        request: requester.appRequest,
+        close: requester.close,
+    };
+}
+function createLazyWorkspaceRequester(options) {
+    let transport;
+    const getTransport = async () => {
+        if (transport) {
+            return transport;
+        }
+        if (hasSshRemote(options)) {
+            transport = createSshToyboxTransport(options);
+        }
+        else {
+            transport = createLocalToyboxTransport(options);
+        }
+        try {
+            transport.start();
+            await initialize(transport);
+            return transport;
+        }
+        catch (error) {
+            transport.close();
+            transport = undefined;
+            throw error;
+        }
+    };
+    return {
+        appRequest: async (method, params) => await (await getTransport()).request(APP_CALL_METHOD, {
+            method,
+            params,
+        }),
+        workspaceRequest: async (method, params) => await (await getTransport()).request(method, params),
+        close: () => {
+            transport?.close();
+            transport = undefined;
+        },
+    };
+}
+async function initializeToybox(options) {
+    return await withWorkspaceTransport(options, async (transport) => await initialize(transport));
+}
+async function callToybox(method, params, options) {
+    return await withWorkspaceTransport(options, async (transport) => {
+        await initialize(transport);
+        return await transport.request(method, params);
+    });
+}
+async function withWorkspaceTransport(options, callback) {
+    if (hasSshRemote(options)) {
+        return await withSshRemoteToyboxTransport(options, callback);
+    }
+    const transport = createLocalToyboxTransport(options);
+    try {
+        transport.start();
+        return await callback(transport);
+    }
+    finally {
+        transport.close();
+    }
+}
+async function initialize(transport) {
+    return await transport.request(TOYBOX_INITIALIZE_METHOD, {
+        clientInfo: {
+            name: "codex-toys-cli",
+            title: "Codex Toys CLI",
+            version: "0.1.0",
+        },
+        capabilities: {
+            appPassThrough: true,
+        },
+    });
+}
+async function collectToyboxInfo(options) {
+    if (hasSshRemote(options)) {
+        return await collectSshToyboxInfo(options);
+    }
+    return await collectLocalToyboxInfo(options);
+}
+async function collectSshToyboxInfo(options) {
+    try {
+        return await withSshRemoteToyboxTransport(options, async (transport) => await collectToyboxInfoFromTransport(transport, "ssh://toybox", "ssh", options.timeoutMs));
+    }
+    catch (error) {
+        return {
+            transport: "ssh",
+            status: "unavailable",
+            error: `toybox: ${errorMessage(error)}`,
+        };
+    }
+}
+async function collectLocalToyboxInfo(options) {
+    const transport = createLocalToyboxTransport(options);
+    transport.on("error", () => { });
+    try {
+        transport.start();
+        return await collectToyboxInfoFromTransport(transport, "toybox://local", "local", options.timeoutMs);
+    }
+    catch (error) {
+        return {
+            transport: "local",
+            status: "unavailable",
+            url: "toybox://local",
+            error: errorMessage(error),
+        };
+    }
+    finally {
+        transport.close();
+    }
+}
+async function collectToyboxInfoFromTransport(transport, url, toyboxTransport, timeoutMs) {
+    return await withProbeTimeout(async () => {
+        const initialized = await initialize(transport);
+        const methods = new Set(initialized.capabilities.toyboxMethods);
+        const threads = await collectThreadsViaWorkspace(transport);
+        const delegations = methods.has("delegation.list")
+            ? await optionalProbe(() => collectDelegations(transport))
+            : undefined;
+        return {
+            transport: toyboxTransport,
+            status: "connected",
+            url,
+            server: initialized.serverInfo,
+            capabilities: {
+                toyboxMethods: initialized.capabilities.toyboxMethods.length,
+            },
+            threads,
+            ...(delegations ? { delegations } : {}),
+        };
+    }, timeoutMs, `toybox probe timed out after ${timeoutMs}ms`);
+}
+async function collectThreadsViaWorkspace(transport) {
+    try {
+        const response = await transport.request(APP_CALL_METHOD, {
+            method: "thread/list",
+            params: threadListParams(),
+        });
+        return summarizeThreads(response);
+    }
+    catch (error) {
+        return {
+            total: 0,
+            active: 0,
+            idle: 0,
+            other: 0,
+            latest: [],
+            error: errorMessage(error),
+        };
+    }
+}
+async function collectDelegations(transport) {
+    const response = record(await transport.request("delegation.list", {}));
+    return summarizeStatusList(arrayValue(response.delegations));
+}
+function threadListParams() {
+    return {
+        limit: 20,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+        archived: false,
+        useStateDbOnly: true,
+    };
+}
+function summarizeThreads(value) {
+    const threads = arrayValue(record(value).data);
+    let active = 0;
+    let idle = 0;
+    let other = 0;
+    const latest = [];
+    for (const thread of threads) {
+        const input = record(thread);
+        const status = threadStatusLabel(input.status);
+        if (status === "active") {
+            active += 1;
+        }
+        else if (status === "idle" || status === "notLoaded") {
+            idle += 1;
+        }
+        else {
+            other += 1;
+        }
+        const id = stringValue(input.id) ?? "unknown";
+        latest.push({
+            id,
+            label: threadLabel(input),
+            status,
+            ...(stringValue(input.cwd) ? { cwd: stringValue(input.cwd) } : {}),
+            ...(typeof input.updatedAt === "number"
+                ? { updatedAt: new Date(input.updatedAt * 1000).toISOString() }
+                : {}),
+        });
+    }
+    return {
+        total: threads.length,
+        active,
+        idle,
+        other,
+        latest,
+    };
+}
+function summarizeStatusList(values) {
+    const counts = {
+        total: values.length,
+        active: 0,
+        idle: 0,
+        failed: 0,
+        complete: 0,
+        reported: 0,
+        other: 0,
+    };
+    for (const value of values) {
+        const status = stringValue(record(value).status);
+        if (status === "active") {
+            counts.active += 1;
+        }
+        else if (status === "idle") {
+            counts.idle = (counts.idle ?? 0) + 1;
+        }
+        else if (status === "failed") {
+            counts.failed = (counts.failed ?? 0) + 1;
+        }
+        else if (status === "complete") {
+            counts.complete = (counts.complete ?? 0) + 1;
+        }
+        else if (status === "reported") {
+            counts.reported = (counts.reported ?? 0) + 1;
+        }
+        else {
+            counts.other = (counts.other ?? 0) + 1;
+        }
+    }
+    return counts;
+}
+async function optionalProbe(callback) {
+    try {
+        return await callback();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function withProbeTimeout(callback, timeoutMs, message) {
+    let timer;
+    try {
+        return await Promise.race([
+            callback(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+function threadStatusLabel(value) {
+    const input = record(value);
+    return stringValue(input.type) ?? "unknown";
+}
+function threadLabel(thread) {
+    const name = stringValue(thread.name);
+    if (name) {
+        return truncate(name, 36);
+    }
+    const preview = stringValue(thread.preview);
+    if (preview) {
+        return truncate(preview.replace(/\s+/g, " "), 36);
+    }
+    return "untitled";
+}
+function truncate(value, maxLength) {
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength - 3)}...`;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function compactUndefined(value) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry !== undefined) {
+            result[key] = entry;
+        }
+    }
+    return result;
+}
+async function readParams(paramsText, paramsFile) {
+    if (paramsText !== undefined) {
+        return parseJson(paramsText);
+    }
+    if (paramsFile !== undefined) {
+        return await readJsonFile(paramsFile, "JSON params file");
+    }
+    if (process.stdin.isTTY) {
+        return undefined;
+    }
+    const text = await readStdin();
+    return text.trim() ? parseJson(text) : undefined;
+}
+async function readStdin() {
+    let text = "";
+    for await (const chunk of process.stdin) {
+        text += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    }
+    return text;
+}
+function parseJson(text) {
+    return parseJsonParamsText(text, "JSON params");
+}
+function writeJson(value, pretty) {
+    write(`${JSON.stringify(value, null, pretty ? 2 : 0)}\n`);
+}
+function write(text) {
+    process.stdout.write(text);
+}
+function helpText() {
+    return `codex-toys controls Codex-native local and SSH toybox surfaces.
+
+Usage:
+  codex-toys fetch [--json] [--no-color]
+  codex-toys neofetch [--json] [--no-color]
+  codex-toys --ssh <target> --cwd <remote-workspace> fetch
+  codex-toys toybox serve [--cwd <path>]
+  codex-toys mcp serve
+
+  codex-toys --ssh <target> --cwd <remote-workspace> remote preflight [--json]
+
+  codex-toys turn run <prompt> [--wait] [--thread-id <id>]
+  codex-toys --ssh <target> --cwd <remote-workspace> turn run <prompt> --wait
+
+  codex-toys automation list [--json]
+  codex-toys automation run <name> [--event <event.json>] [--prompt <text>] [--via workspace|app]
+  codex-toys --ssh <target> --cwd <remote-workspace> automation list [--json]
+  codex-toys --ssh <target> --cwd <remote-workspace> automation run <name> [--event <event.json>]
+
+  codex-toys app <method> [params-json]
+  codex-toys app <method> --params-json <json>
+  codex-toys app <method> --params-file <file>
+  codex-toys app call <method> [params-json]
+  echo '<params-json>' | codex-toys app <method>
+  codex-toys app actions
+
+  codex-toys functions list [--json]
+  codex-toys functions describe <name> [--json]
+  codex-toys functions call <name> [--params-json <json>] [--json]
+  codex-toys --ssh <target> --cwd <remote-workspace> functions list [--json]
+
+  codex-toys workspace <method> [params-json]
+  codex-toys workspace <method> --params-json <json>
+  codex-toys workspace <method> --params-file <file>
+  codex-toys workspace call <method> [params-json]
+  codex-toys workspace app <method> [params-json]
+  codex-toys workspace methods
+  codex-toys workspace delegate list [--json]
+  codex-toys workspace delegate start --cwd @/workspaces/name --prompt <text> [--wait]
+  codex-toys workspace doctor [--mode auto|local|actions] [--json]
+  codex-toys workspace tick [--mode auto|local|actions]
+  codex-toys workspace run <task-id> [--mode auto|local|actions]
+  codex-toys workspace init actions [--forgejo|--github]
+
+  codex-toys actions prepare-auth
+  codex-toys actions cleanup
+
+  codex-toys memories transplant global-to-workspace [--apply]
+  codex-toys memories transplant workspace-to-global [--apply]
+
+  codex-toys threads locate <thread-id> [--codex-home <home>]
+  codex-toys threads inspect <thread-id-or-rollout.jsonl> [--codex-home <home>]
+  codex-toys threads install-rollout <rollout.jsonl> [--codex-home <home>] [--replace]
+  codex-toys threads transplant <thread-id> --from-codex-home <src> --to-codex-home <dst> [--replace]
+
+  codex-toys pack inspect <source> [--json]
+  codex-toys pack add <source> [--apply] [--include <name>] [--exclude <name>]
+  codex-toys pack doctor [--json]
+  codex-toys pack list [--json]
+
+Options:
+  --timeout-ms <ms>                          Request timeout. Defaults to 90000,
+                                             1500 for local fetch probes, or
+                                             1800000 for automation run and
+                                             waited turns.
+  --compact                                  Print compact JSON.
+  --pretty                                   Print pretty JSON.
+  --json                                     Print JSON for supported commands.
+  --no-color                                 Disable ANSI colors for fetch.
+  --mode <auto|local|actions>                Workspace execution mode.
+  --workspace-root <path>                    Workspace root. Defaults to discovery.
+  --global-codex-home <path>                 Global Codex home for memories transplant.
+  --workspace-codex-home <path>              Workspace Codex home for memories transplant.
+  --codex-home <path>                        Codex home for thread transplant.
+  --from-codex-home <path>                   Source Codex home for direct thread transplant.
+  --to-codex-home <path>                     Target Codex home for direct thread transplant.
+  --apply                                    Apply memory transplant changes.
+  --overwrite                                Replace destination memory files after backup.
+                                             For pack add, replace changed installed item dirs
+                                             after backup under .codex/pack-backups.
+  --replace                                  Replace an existing thread rollout after backup.
+  --ref <ref>                                Git ref for non-local pack sources.
+  --include <name>                           Include a pack item by name or kind:name.
+  --exclude <name>                           Exclude a pack item by name or kind:name.
+  --merge codex                              Merge MEMORY.md and memory_summary.md with Codex.
+  --no-backup                                Disable overwrite/merge backups.
+  --event <path>                             Event JSON for automation, Actions,
+                                             or workspace tasks.
+  --forgejo                                  Generate a Forgejo Actions workflow.
+  --github                                   Generate a GitHub Actions workflow.
+  --prompt <text>                            Prompt text for automation script context.
+  --title <text>                             Delegation thread title.
+  --group-id <id>                            Delegation group id.
+  --return-mode <mode>                       Delegation return mode: detached,
+                                             record_only, wake_on_done,
+                                             wake_on_group, or manual.
+  --allow-absolute-cwd                       Allow workspace delegation to target
+                                             an absolute cwd.
+  --target-cwd <path>                        Delegation target cwd. Useful with
+                                             --ssh, where --cwd selects the
+                                             remote workspace root.
+  --via <workspace|app>                      Turn surface. Defaults to workspace.
+  --sandbox <mode>                           Turn sandbox: danger-full-access,
+                                             workspace-write, or read-only.
+  --approval-policy <policy>                 Turn approval policy: never,
+                                             on-failure, on-request, or untrusted.
+  --permissions <profile>                    Turn permissions profile.
+  --ssh, --ssh-target <target>               SSH target for remote CodexToys operation
+                                             Defaults to CODEX_TOYS_REMOTE_SSH_TARGET.
+  --remote-path-prepend <paths>              Colon-separated remote PATH entries for
+                                             non-interactive SSH commands.
+  --toybox-command <command>                  codex-toys command/path for spawned toyboxes.
+                                             Defaults to CODEX_TOYS_TOYBOX_COMMAND
+                                             or codex-toys.
+  --codex-command <command>                  Codex command used by the toybox.
+                                             Defaults to CODEX_TOYS_REMOTE_CODEX_COMMAND or codex.
+  --codex-arg <arg>                          Extra Codex argument. Repeatable.
+  --cwd <path>                               Remote workspace cwd for SSH operation.
+                                             For local workspace delegate, also
+                                             accepts @/path relative to the
+                                             workspace root.
+  -h, --help                                 Show this help.
+
+Examples:
+  codex-toys fetch
+  codex-toys mcp serve
+  codex-toys toybox serve --cwd /repo
+  codex-toys --ssh devbox --cwd /repo fetch
+  codex-toys --ssh devbox --cwd /repo turn run "Scan current folder" --wait
+  codex-toys automation list
+  codex-toys automation run check-release --event event.json
+  codex-toys --ssh devbox --cwd /repo automation list --json
+  codex-toys --ssh devbox --cwd /repo automation run check-release --event event.json
+  codex-toys --ssh devbox --cwd /repo functions list --json
+  codex-toys --ssh devbox --cwd /repo functions call portfolioSnapshot --json
+  codex-toys --ssh devbox --cwd /repo app thread/list '{"limit":20,"sourceKinds":[]}'
+  codex-toys --ssh devbox --cwd /repo workspace delegation.list
+  codex-toys app thread/list '{"limit":20,"sourceKinds":[]}'
+  codex-toys workspace app thread/list '{"limit":20,"sourceKinds":[]}'
+  codex-toys workspace delegation.list
+  codex-toys workspace delegate start --cwd @/workspaces/trading --prompt "Inspect status"
+  codex-toys workspace doctor --mode actions
+  codex-toys workspace init actions --forgejo
+  codex-toys memories transplant global-to-workspace
+  codex-toys threads inspect 019e3654-1492-70d0-9b01-46b17d6444a9 --codex-home ./.codex
+  codex-toys threads install-rollout ./rollout-2026-05-18T15-12-25-019e3ba5-3c2a-74c1-bece-53a8ece3dc0e.jsonl --codex-home ./.codex
+  codex-toys threads transplant 019e3654-1492-70d0-9b01-46b17d6444a9 --from-codex-home ~/.codex --to-codex-home ./.codex
+  codex-toys pack inspect owner/repo
+  codex-toys pack add ./capability-pack --apply
+`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=index.js.map