codex-toys 0.140.2 → 0.140.4

package/dist/cli/args.js

@@ -40,7 +40,21 @@ export function parseArgs(argv, env = process.env) {
     let includeOutput = false;
     let olderThanDays;
     let cursor;
+    let runAt;
     let model;
+    let serviceTier;
+    let effort;
+    let queue;
+    let promptQueue;
+    let afterIntentId;
+    let afterStatus;
+    let status;
+    let limit;
+    let targetHost;
+    let hostId;
+    let requesterHost;
+    let requesterThreadId;
+    let materialize = false;
     let paramsJson;
     let paramsFile;
     let cwd = env.CODEX_TOYS_REMOTE_CWD;
@@ -55,6 +69,8 @@ export function parseArgs(argv, env = process.env) {
     let permissions;
     const include = [];
     const exclude = [];
+    const labels = [];
+    const capabilities = [];
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index];
         if (!arg) {
@@ -323,6 +339,118 @@ export function parseArgs(argv, env = process.env) {
             cursor = arg.slice("--cursor=".length);
             continue;
         }
+        if (arg === "--run-at") {
+            runAt = required(argv, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--run-at=")) {
+            runAt = arg.slice("--run-at=".length);
+            continue;
+        }
+        if (arg === "--queue") {
+            queue = required(argv, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--queue=")) {
+            queue = arg.slice("--queue=".length);
+            continue;
+        }
+        if (arg === "--prompt-queue") {
+            promptQueue = required(argv, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--prompt-queue=")) {
+            promptQueue = arg.slice("--prompt-queue=".length);
+            continue;
+        }
+        if (arg === "--label") {
+            labels.push(required(argv, ++index, arg));
+            continue;
+        }
+        if (arg.startsWith("--label=")) {
+            labels.push(arg.slice("--label=".length));
+            continue;
+        }
+        if (arg === "--capability" || arg === "--required-capability") {
+            capabilities.push(required(argv, ++index, arg));
+            continue;
+        }
+        if (arg.startsWith("--capability=")) {
+            capabilities.push(arg.slice("--capability=".length));
+            continue;
+        }
+        if (arg.startsWith("--required-capability=")) {
+            capabilities.push(arg.slice("--required-capability=".length));
+            continue;
+        }
+        if (arg === "--target-host") {
+            targetHost = required(argv, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--target-host=")) {
+            targetHost = arg.slice("--target-host=".length);
+            continue;
+        }
+        if (arg === "--host-id") {
+            hostId = required(argv, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--host-id=")) {
+            hostId = arg.slice("--host-id=".length);
+            continue;
+        }
+        if (arg === "--requester-host") {
+            requesterHost = required(argv, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--requester-host=")) {
+            requesterHost = arg.slice("--requester-host=".length);
+            continue;
+        }
+        if (arg === "--requester-thread-id") {
+            requesterThreadId = required(argv, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--requester-thread-id=")) {
+            requesterThreadId = arg.slice("--requester-thread-id=".length);
+            continue;
+        }
+        if (arg === "--materialize") {
+            materialize = true;
+            continue;
+        }
+        if (arg === "--after") {
+            afterIntentId = required(argv, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--after=")) {
+            afterIntentId = arg.slice("--after=".length);
+            continue;
+        }
+        if (arg === "--after-status") {
+            afterStatus = parseDeferredDependencyStatus(required(argv, ++index, arg));
+            continue;
+        }
+        if (arg.startsWith("--after-status=")) {
+            afterStatus = parseDeferredDependencyStatus(arg.slice("--after-status=".length));
+            continue;
+        }
+        if (arg === "--status") {
+            status = parseDeferredRunStatus(required(argv, ++index, arg));
+            continue;
+        }
+        if (arg.startsWith("--status=")) {
+            status = parseDeferredRunStatus(arg.slice("--status=".length));
+            continue;
+        }
+        if (arg === "--limit") {
+            limit = positiveInteger(required(argv, ++index, arg), arg);
+            continue;
+        }
+        if (arg.startsWith("--limit=")) {
+            limit = positiveInteger(arg.slice("--limit=".length), "--limit");
+            continue;
+        }
         if (arg === "--allow-absolute-cwd") {
             allowAbsoluteCwd = true;
             continue;
@@ -335,6 +463,22 @@ export function parseArgs(argv, env = process.env) {
             model = arg.slice("--model=".length);
             continue;
         }
+        if (arg === "--service-tier") {
+            serviceTier = required(argv, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--service-tier=")) {
+            serviceTier = arg.slice("--service-tier=".length);
+            continue;
+        }
+        if (arg === "--effort") {
+            effort = parseReasoningEffort(required(argv, ++index, arg));
+            continue;
+        }
+        if (arg.startsWith("--effort=")) {
+            effort = parseReasoningEffort(arg.slice("--effort=".length));
+            continue;
+        }
         if (arg === "--via") {
             via = parseRemoteVia(required(argv, ++index, arg));
             continue;
@@ -499,7 +643,31 @@ export function parseArgs(argv, env = process.env) {
                 ...remoteFields(),
             };
         }
-        throw new Error("remote supports only preflight; use --ssh with fetch, app, workspace, automation, functions, or turn run");
+        if (subcommand === "host-overview" || subcommand === "host") {
+            return {
+                type: "host-overview",
+                url: workspaceUrl,
+                timeoutMs,
+                json,
+                pretty,
+                ...remoteFields(),
+            };
+        }
+        throw new Error("remote supports only preflight or host-overview; use --ssh with fetch, app, workspace, automation, functions, or turn run");
+    }
+    if (command === "host") {
+        const subcommand = positionals[1];
+        if (subcommand !== "overview") {
+            throw new Error("host requires overview");
+        }
+        return {
+            type: "host-overview",
+            url: workspaceUrl,
+            timeoutMs,
+            json,
+            pretty,
+            ...remoteFields(),
+        };
     }
     if (command === "turn") {
         const subcommand = positionals[1];
@@ -642,6 +810,18 @@ export function parseArgs(argv, env = process.env) {
                 ...remoteFields(),
             };
         }
+        if (subcommand === "overview") {
+            return {
+                type: "workspace-overview",
+                mode,
+                workspaceRoot,
+                url: workspaceUrl,
+                timeoutMs: timeoutMs === defaultTimeoutMs ? 5_000 : timeoutMs,
+                json,
+                pretty,
+                ...remoteFields(),
+            };
+        }
         if (subcommand === "delegate" || subcommand === "delegation") {
             const action = positionals[2] ?? "list";
             if (action === "list" || action === "ls") {
@@ -692,6 +872,242 @@ export function parseArgs(argv, env = process.env) {
                 ...remoteFields(),
             };
         }
+        if (subcommand === "prompt" || subcommand === "prompts" || subcommand === "prompt-queue") {
+            const action = positionals[2] ?? "list";
+            if (action === "enqueue" || action === "queue" || action === "add" || action === "create") {
+                const positionalPrompt = positionals.slice(3).join(" ");
+                return {
+                    type: "workspace-prompt-enqueue",
+                    prompt: prompt ?? (positionalPrompt || requiredPositional(positionals, 3, "workspace prompt enqueue requires <prompt> or --prompt <text>")),
+                    title,
+                    queue,
+                    labels,
+                    runAt,
+                    afterIntentId,
+                    afterStatus,
+                    threadId,
+                    cwd: targetCwd ?? (!sshTarget ? cwd : undefined),
+                    model,
+                    serviceTier,
+                    effort,
+                    sandbox,
+                    approvalPolicy,
+                    permissions,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "list" || action === "ls") {
+                return {
+                    type: "workspace-prompt-list",
+                    status,
+                    queue,
+                    limit,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    json,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "read" || action === "show" || action === "pull") {
+                return {
+                    type: "workspace-prompt-read",
+                    intentId: requiredPositional(positionals, 3, `workspace prompt ${action} requires <intent-id>`),
+                    includeOutput: includeOutput || action === "pull",
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    json,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "collect") {
+                return {
+                    type: "workspace-prompt-collect",
+                    cursor,
+                    queue,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    json,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "cancel") {
+                return {
+                    type: "workspace-prompt-cancel",
+                    intentId: requiredPositional(positionals, 3, "workspace prompt cancel requires <intent-id>"),
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "retry" || action === "requeue") {
+                return {
+                    type: "workspace-prompt-retry",
+                    intentId: requiredPositional(positionals, 3, `workspace prompt ${action} requires <intent-id>`),
+                    runAt,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "run-due" || action === "run") {
+                return {
+                    type: "workspace-prompt-run-due",
+                    queue,
+                    limit,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            throw new Error("workspace prompt requires enqueue, list, read, collect, cancel, retry, or run-due");
+        }
+        if (subcommand === "handoff" || subcommand === "handoffs" || subcommand === "local-handoff") {
+            const action = positionals[2] ?? "list";
+            if (action === "enqueue" || action === "queue" || action === "add" || action === "create") {
+                const positionalPrompt = positionals.slice(3).join(" ");
+                return {
+                    type: "workspace-handoff-enqueue",
+                    prompt: prompt ?? (positionalPrompt || requiredPositional(positionals, 3, "workspace handoff enqueue requires <prompt> or --prompt <text>")),
+                    title,
+                    queue,
+                    labels,
+                    runAt,
+                    afterIntentId,
+                    afterStatus,
+                    targetHost,
+                    requiredCapabilities: capabilities,
+                    requesterHost,
+                    requesterThreadId,
+                    threadId,
+                    cwd: targetCwd ?? (!sshTarget ? cwd : undefined),
+                    model,
+                    serviceTier,
+                    effort,
+                    sandbox,
+                    approvalPolicy,
+                    permissions,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "list" || action === "ls") {
+                return {
+                    type: "workspace-handoff-list",
+                    status,
+                    queue,
+                    targetHost,
+                    capabilities,
+                    limit,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    json,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "read" || action === "show" || action === "pull") {
+                return {
+                    type: "workspace-handoff-read",
+                    intentId: requiredPositional(positionals, 3, `workspace handoff ${action} requires <intent-id>`),
+                    includeOutput: includeOutput || action === "pull",
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    json,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "collect") {
+                return {
+                    type: "workspace-handoff-collect",
+                    cursor,
+                    queue,
+                    targetHost,
+                    capabilities,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    json,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "cancel") {
+                return {
+                    type: "workspace-handoff-cancel",
+                    intentId: requiredPositional(positionals, 3, "workspace handoff cancel requires <intent-id>"),
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "retry" || action === "requeue") {
+                return {
+                    type: "workspace-handoff-retry",
+                    intentId: requiredPositional(positionals, 3, `workspace handoff ${action} requires <intent-id>`),
+                    runAt,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            if (action === "drain" || action === "run-due" || action === "run") {
+                return {
+                    type: "workspace-handoff-drain",
+                    queue,
+                    hostId,
+                    capabilities,
+                    limit,
+                    materialize,
+                    promptQueue,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
+            throw new Error("workspace handoff requires enqueue, list, read, collect, cancel, retry, or drain");
+        }
         if (subcommand === "deferred" || subcommand === "defer") {
             const action = positionals[2] ?? "list";
             if (action === "create" || action === "add") {
@@ -757,6 +1173,19 @@ export function parseArgs(argv, env = process.env) {
                     ...remoteFields(),
                 };
             }
+            if (action === "retry" || action === "requeue") {
+                return {
+                    type: "workspace-deferred-retry",
+                    intentId: requiredPositional(positionals, 3, `workspace deferred ${action} requires <intent-id>`),
+                    runAt,
+                    mode,
+                    workspaceRoot,
+                    url: workspaceUrl,
+                    timeoutMs,
+                    pretty,
+                    ...remoteFields(),
+                };
+            }
             if (action === "run-due" || action === "run") {
                 return {
                     type: "workspace-deferred-run-due",
@@ -784,7 +1213,7 @@ export function parseArgs(argv, env = process.env) {
                     ...remoteFields(),
                 };
             }
-            throw new Error("workspace deferred requires create, list, read, collect, cancel, run-due, or prune");
+            throw new Error("workspace deferred requires create, list, read, collect, cancel, retry, run-due, or prune");
         }
         if (subcommand === "run") {
             return {
@@ -995,6 +1424,36 @@ function parseRemoteTurnApprovalPolicy(value) {
     }
     throw new Error("--approval-policy must be never, on-failure, on-request, or untrusted");
 }
+function parseReasoningEffort(value) {
+    if (value === "none" ||
+        value === "minimal" ||
+        value === "low" ||
+        value === "medium" ||
+        value === "high" ||
+        value === "xhigh") {
+        return value;
+    }
+    throw new Error("--effort must be none, minimal, low, medium, high, or xhigh");
+}
+function parseDeferredDependencyStatus(value) {
+    if (value === "completed" ||
+        value === "failed" ||
+        value === "canceled" ||
+        value === "terminal") {
+        return value;
+    }
+    throw new Error("--after-status must be completed, failed, canceled, or terminal");
+}
+function parseDeferredRunStatus(value) {
+    if (value === "pending" ||
+        value === "running" ||
+        value === "completed" ||
+        value === "failed" ||
+        value === "canceled") {
+        return value;
+    }
+    throw new Error("--status must be pending, running, completed, failed, or canceled");
+}
 function parseDelegationReturnMode(value) {
     if (value === "detached" ||
         value === "record_only" ||