@steipete/oracle 0.16.1 → 0.17.1

package/dist/bin/oracle-cli.js

@@ -21,7 +21,7 @@ import { applyHelpStyling } from "../src/cli/help.js";
 import { collectPaths, collectModelList, collectTextValues, parseFloatOption, parseIntOption, parseSearchOption, parseThinkingTimeOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, normalizeBaseUrl, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, parseTimeoutOption, parseDurationOption, mergePathLikeOptions, dedupePathInputs, } from "../src/cli/options.js";
 import { copyToClipboard } from "../src/cli/clipboard.js";
 import { buildMarkdownBundle } from "../src/cli/markdownBundle.js";
-import { shouldDetachSession } from "../src/cli/detach.js";
+import { shouldDetachSession, stopDetachedWorker } from "../src/cli/detach.js";
 import { applyHiddenAliases } from "../src/cli/hiddenAliases.js";
 import { isMediaFile } from "../src/browser/prompt.js";
 import { formatCompactNumber } from "../src/cli/format.js";
@@ -227,10 +227,19 @@ program
     .addOption(new Option("--copy-markdown", "Copy the assembled markdown bundle to the clipboard; pair with --render to print it too.").default(false))
     .addOption(new Option("--copy").hideHelp().default(false))
     .option("-s, --slug <words>", "Custom session slug (3-5 words).")
-    .option("-m, --model <model>", 'Model to target (gpt-5.5-pro default). GPT-5.6 aliases: gpt-5.6 and gpt-5.6-sol (OpenAI API or ChatGPT browser). Also gpt-5.5, gpt-5.4-pro, gpt-5.4, gpt-5.1-pro, gpt-5-pro, gpt-5.1, gpt-5.1-codex API-only, gpt-5.2, gpt-5.2-instant, gpt-5.2-pro, gemini-3.1-flash-lite, gemini-3.5-flash, gemini-3.1-pro, legacy gemini-3-pro, claude-4.6-sonnet, claude-4.1-opus, or ChatGPT labels like "5.5 Pro" / "5.2 Thinking" for browser runs).', normalizeModelOption)
+    .option("-m, --model <model>", "Model to target (gpt-5.5-pro default). GPT-5.6 aliases gpt-5.6 and gpt-5.6-sol work with the OpenAI API or ChatGPT browser. Browser mode also supports current GPT-5.5/GPT-5.4 targets and legacy Pro aliases; retired GPT-5.2 base/Instant/Thinking aliases are API-only. Other API targets include gpt-5.1-codex, gpt-5.2, gpt-5.2-instant, Gemini, Claude, and custom model IDs.", normalizeModelOption)
     .addOption(new Option("--models <models>", 'Comma-separated API model list to query in parallel (e.g., "gpt-5.5-pro,gemini-3-pro").')
     .argParser(collectModelList)
     .default([]))
+    .addOption(new Option("--reasoning-effort <effort>", "Reasoning effort for GPT-5.6 API models.").choices([
+    "none",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]))
+    .addOption(new Option("--reasoning-mode <mode>", 'Responses API reasoning execution mode for GPT-5.6 models ("standard" or "pro").').choices(["standard", "pro"]))
     .addOption(new Option("-e, --engine <mode>", "Execution engine (api | browser). Browser engine: GPT models automate ChatGPT; Gemini models use a cookie-based client for gemini.google.com. If omitted, oracle picks api when OPENAI_API_KEY is set, otherwise browser.").choices(["api", "browser"]))
     .addOption(new Option("--mode <mode>", "Alias for --engine (api | browser).")
     .choices(["api", "browser"])
@@ -330,7 +339,7 @@ program
     .addOption(new Option("--browser-hide-window", "Hide the Chrome window after launch (macOS headful only).").hideHelp())
     .addOption(new Option("--browser-keep-browser", "Keep Chrome running after completion.").hideHelp())
     .addOption(new Option("--browser-model-strategy <mode>", "ChatGPT model picker strategy: select (default) switches to the requested model, current keeps the active model, ignore skips the picker entirely.").choices(["select", "current", "ignore"]))
-    .addOption(new Option("--browser-thinking-time <level>", "Thinking time intensity for Thinking/Pro models: light, standard, extended, heavy, or ChatGPT UI aliases.")
+    .addOption(new Option("--browser-thinking-time <level>", "Thinking time intensity for Thinking/Pro models: light, standard, extended, extra-high (Extra High), heavy (Pro), or ChatGPT UI aliases.")
     .argParser(parseThinkingTimeOption)
     .hideHelp())
     .addOption(new Option("--browser-research <mode>", "Browser research mode: deep activates ChatGPT Deep Research.").choices(["off", "deep"]))
@@ -659,6 +668,8 @@ function buildRunOptions(options, overrides = {}) {
         prompt: options.prompt,
         model: options.model,
         models: overrides.models ?? options.models,
+        reasoningEffort: overrides.reasoningEffort ?? options.reasoningEffort,
+        reasoningMode: overrides.reasoningMode ?? options.reasoningMode,
         previousResponseId: overrides.previousResponseId ?? options.previousResponseId,
         browserResumeConversationUrl: overrides.browserResumeConversationUrl ?? options.browserResumeConversationUrl,
         effectiveModelId: overrides.effectiveModelId ?? options.effectiveModelId ?? options.model,
@@ -902,6 +913,8 @@ function buildRunOptionsFromMetadata(metadata) {
         browserResumeConversationUrl: stored.browserResumeConversationUrl,
         effectiveModelId: stored.effectiveModelId ?? stored.model,
         modelOverrides: stored.modelOverrides,
+        reasoningEffort: stored.reasoningEffort,
+        reasoningMode: stored.reasoningMode,
         file: stored.file ?? [],
         maxFileSizeBytes: stored.maxFileSizeBytes,
         slug: stored.slug,
@@ -929,6 +942,8 @@ function buildRunOptionsFromMetadata(metadata) {
         browserInlineFiles: stored.browserInlineFiles,
         browserBundleFiles: stored.browserBundleFiles,
         browserBundleFormat: stored.browserBundleFormat,
+        generateImage: stored.generateImage,
+        outputPath: stored.outputPath,
         browserFollowUps: stored.browserFollowUps,
         background: stored.background,
         renderPlain: stored.renderPlain,
@@ -1213,6 +1228,7 @@ async function runRootCommand(options) {
         return;
     }
     if (options.execSession) {
+        await waitForDetachedStartGate();
         await executeSession(options.execSession);
         return;
     }
@@ -1296,6 +1312,12 @@ async function runRootCommand(options) {
         }
     }
     const activeModel = resolvedOptions.model;
+    if (options.reasoningMode && engine !== "api") {
+        throw new Error("--reasoning-mode requires --engine api.");
+    }
+    if (options.reasoningEffort && engine !== "api") {
+        throw new Error("--reasoning-effort requires --engine api.");
+    }
     const browserFollowUpCount = options.browserFollowUp?.filter((entry) => entry.trim().length > 0).length ?? 0;
     if (engine !== "browser" && browserFollowUpCount > 0) {
         throw new Error("--browser-follow-up requires --engine browser.");
@@ -1445,13 +1467,16 @@ async function runRootCommand(options) {
         }, {});
         return;
     }
-    // Decide whether to block until completion:
+    // Decide whether the original CLI stays attached until completion:
     // - explicit --wait / --no-wait wins
-    // - otherwise block for fast models (gpt-5.1, browser) and detach by default for pro API runs
+    // - otherwise stay attached for fast models and browser runs
+    // Local Pro browser work may still use a detached worker so CLI interruption
+    // cannot terminate the browser controller.
     let waitPreference = resolveWaitFlag({
         waitFlag: options.wait,
         model: activeModel,
         engine,
+        reasoningMode: resolvedOptions.reasoningMode,
     });
     if (remoteHost && waitPreference === false) {
         console.log(chalk.dim("Remote browser runs require --wait; ignoring --no-wait."));
@@ -1498,22 +1523,34 @@ async function runRootCommand(options) {
         : shouldDetachSession({
             engine,
             model: activeModel,
+            reasoningMode: resolvedOptions.reasoningMode,
             waitPreference,
             disableDetachEnv,
         });
-    const detached = !detachAllowed
-        ? false
-        : await launchDetachedSession(sessionMeta.id).catch((error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            console.log(chalk.yellow(`Unable to detach session runner (${message}). Running inline...`));
-            return false;
-        });
-    const lifecycle = buildSessionLifecycle({
+    let lifecycle = buildSessionLifecycle({
         engine,
-        detached,
+        detached: false,
         reattachCommand: `oracle session ${sessionMeta.id}`,
     });
-    await sessionStore.updateSession(sessionMeta.id, { lifecycle });
+    const workerPid = !detachAllowed
+        ? undefined
+        : await launchDetachedSession(sessionMeta.id, async (pid) => {
+            lifecycle = buildSessionLifecycle({
+                engine,
+                detached: true,
+                workerPid: pid,
+                reattachCommand: `oracle session ${sessionMeta.id}`,
+            });
+            await sessionStore.updateSession(sessionMeta.id, { lifecycle });
+        }).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log(chalk.yellow(`Unable to detach session runner (${message}). Running inline...`));
+            return undefined;
+        });
+    const detached = workerPid !== undefined;
+    if (!detached) {
+        await sessionStore.updateSession(sessionMeta.id, { lifecycle });
+    }
     const sessionWithLifecycle = { ...sessionMeta, lifecycle };
     if (!waitPreference) {
         if (!detached) {
@@ -1533,8 +1570,7 @@ async function runRootCommand(options) {
     }
     if (detached) {
         console.log(chalk.blue(`Reattach via: oracle session ${sessionMeta.id}`));
-        const { attachSession } = await import("../src/cli/sessionDisplay.js");
-        await attachSession(sessionMeta.id, { suppressMetadata: true });
+        await attachToDetachedSession(sessionMeta.id, workerPid);
     }
 }
 async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfig, showReattachHint = true, notifications, userConfig, suppressSummary = false, browserDeps, cwd = process.cwd()) {
@@ -1593,20 +1629,35 @@ async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfi
         stream.end();
     }
 }
-async function launchDetachedSession(sessionId) {
+async function launchDetachedSession(sessionId, prepare) {
     return new Promise((resolve, reject) => {
         try {
             const args = ["--", CLI_ENTRYPOINT, "--exec-session", sessionId];
-            const env = buildDetachedPerfTraceEnv(process.env, perfTraceArgs.value, sessionId);
+            const env = {
+                ...buildDetachedPerfTraceEnv(process.env, perfTraceArgs.value, sessionId),
+                ORACLE_DETACHED_START_GATE: "1",
+            };
             const child = spawn(process.execPath, args, {
                 detached: true,
-                stdio: "ignore",
+                stdio: ["pipe", "ignore", "ignore"],
                 env,
             });
             child.once("error", reject);
-            child.once("spawn", () => {
-                child.unref();
-                resolve(true);
+            child.once("spawn", async () => {
+                if (child.pid === undefined) {
+                    reject(new Error("Detached session worker started without a process ID."));
+                    return;
+                }
+                try {
+                    await prepare(child.pid);
+                    child.stdin.end("ready\n");
+                    child.unref();
+                    resolve(child.pid);
+                }
+                catch (error) {
+                    child.kill();
+                    reject(error);
+                }
             });
         }
         catch (error) {
@@ -1614,6 +1665,49 @@ async function launchDetachedSession(sessionId) {
         }
     });
 }
+async function waitForDetachedStartGate() {
+    if (process.env.ORACLE_DETACHED_START_GATE !== "1") {
+        return;
+    }
+    const chunks = [];
+    await new Promise((resolve, reject) => {
+        process.stdin.on("data", (chunk) => chunks.push(chunk));
+        process.stdin.once("end", resolve);
+        process.stdin.once("error", reject);
+        process.stdin.resume();
+    });
+    if (Buffer.concat(chunks).toString("utf8") !== "ready\n") {
+        throw new Error("Detached session worker start gate closed before lifecycle handoff.");
+    }
+}
+async function attachToDetachedSession(sessionId, workerPid) {
+    let cancelled = false;
+    const cancelWorker = () => {
+        cancelled = true;
+        try {
+            stopDetachedWorker(workerPid);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`Unable to stop detached worker ${workerPid}: ${message}`));
+        }
+    };
+    process.once("SIGINT", cancelWorker);
+    try {
+        const { attachSession } = await import("../src/cli/sessionDisplay.js");
+        await attachSession(sessionId, {
+            suppressMetadata: true,
+            renderPrompt: false,
+            propagateFailure: true,
+        });
+    }
+    finally {
+        process.off("SIGINT", cancelWorker);
+        if (cancelled) {
+            process.exitCode = 130;
+        }
+    }
+}
 async function restartSession(sessionId, options) {
     const metadata = await sessionStore.readSession(sessionId);
     if (!metadata) {
@@ -1657,6 +1751,7 @@ async function restartSession(sessionId, options) {
         storedPreference: storedOptions.waitPreference,
         model: runOptions.model,
         engine,
+        reasoningMode: runOptions.reasoningMode,
     });
     const remoteConfig = resolveRemoteServiceConfig({
         cliHost: options.remoteHost,
@@ -1732,22 +1827,34 @@ async function restartSession(sessionId, options) {
         : shouldDetachSession({
             engine,
             model: runOptions.model,
+            reasoningMode: runOptions.reasoningMode,
             waitPreference,
             disableDetachEnv,
         });
-    const detached = !detachAllowed
-        ? false
-        : await launchDetachedSession(sessionMeta.id).catch((error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            console.log(chalk.yellow(`Unable to detach session runner (${message}). Running inline...`));
-            return false;
-        });
-    const lifecycle = buildSessionLifecycle({
+    let lifecycle = buildSessionLifecycle({
         engine,
-        detached,
+        detached: false,
         reattachCommand: `oracle session ${sessionMeta.id}`,
     });
-    await sessionStore.updateSession(sessionMeta.id, { lifecycle });
+    const workerPid = !detachAllowed
+        ? undefined
+        : await launchDetachedSession(sessionMeta.id, async (pid) => {
+            lifecycle = buildSessionLifecycle({
+                engine,
+                detached: true,
+                workerPid: pid,
+                reattachCommand: `oracle session ${sessionMeta.id}`,
+            });
+            await sessionStore.updateSession(sessionMeta.id, { lifecycle });
+        }).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log(chalk.yellow(`Unable to detach session runner (${message}). Running inline...`));
+            return undefined;
+        });
+    const detached = workerPid !== undefined;
+    if (!detached) {
+        await sessionStore.updateSession(sessionMeta.id, { lifecycle });
+    }
     const sessionWithLifecycle = { ...sessionMeta, lifecycle };
     if (!waitPreference) {
         if (!detached) {
@@ -1767,24 +1874,27 @@ async function restartSession(sessionId, options) {
     }
     if (detached) {
         console.log(chalk.blue(`Reattach via: oracle session ${sessionMeta.id}`));
-        const { attachSession } = await import("../src/cli/sessionDisplay.js");
-        await attachSession(sessionMeta.id, { suppressMetadata: true });
+        await attachToDetachedSession(sessionMeta.id, workerPid);
     }
 }
 async function executeSession(sessionId) {
-    const metadata = await sessionStore.readSession(sessionId);
-    if (!metadata) {
-        console.error(chalk.red(`No session found with ID ${sessionId}`));
-        process.exitCode = 1;
-        return;
-    }
-    const runOptions = buildRunOptionsFromMetadata(metadata);
-    const sessionMode = getSessionMode(metadata);
-    const browserConfig = getBrowserConfigFromMetadata(metadata);
-    const { logLine, writeChunk, stream } = sessionStore.createLogWriter(sessionId);
-    const userConfig = (await loadUserConfig()).config;
-    const notifications = deriveNotificationSettingsFromMetadata(metadata, process.env, userConfig.notify);
+    let metadata = null;
+    let writer = null;
     try {
+        metadata = await sessionStore.readSession(sessionId);
+        if (!metadata) {
+            throw new Error(`No session found with ID ${sessionId}`);
+        }
+        if (process.env.ORACLE_DETACHED_START_GATE === "1" &&
+            metadata.lifecycle?.workerPid !== process.pid) {
+            throw new Error("Detached session worker started without a matching lifecycle handoff.");
+        }
+        const runOptions = buildRunOptionsFromMetadata(metadata);
+        const sessionMode = getSessionMode(metadata);
+        const browserConfig = getBrowserConfigFromMetadata(metadata);
+        writer = sessionStore.createLogWriter(sessionId);
+        const userConfig = (await loadUserConfig()).config;
+        const notifications = deriveNotificationSettingsFromMetadata(metadata, process.env, userConfig.notify);
         const { performSessionRun } = await import("../src/cli/sessionRunner.js");
         await performSessionRun({
             sessionMeta: metadata,
@@ -1792,17 +1902,36 @@ async function executeSession(sessionId) {
             mode: sessionMode,
             browserConfig,
             cwd: metadata.cwd ?? process.cwd(),
-            log: logLine,
-            write: writeChunk,
+            log: writer.logLine,
+            write: writer.writeChunk,
             version: VERSION,
             notifications,
         });
     }
-    catch {
-        // Errors are already logged to the session log; keep quiet to mirror stored-session behavior.
+    catch (error) {
+        process.exitCode = 1;
+        const message = error instanceof Error ? error.message : String(error);
+        if (!metadata) {
+            console.error(chalk.red(message));
+            return;
+        }
+        writer?.logLine(`ERROR: Detached session worker failed: ${message}`);
+        const latest = await sessionStore.readSession(sessionId).catch(() => null);
+        if (latest && !["completed", "partial", "error"].includes(latest.status)) {
+            await sessionStore.updateSession(sessionId, {
+                status: "error",
+                completedAt: new Date().toISOString(),
+                errorMessage: message,
+                response: { status: "error" },
+                error: {
+                    category: "internal",
+                    message,
+                },
+            });
+        }
     }
     finally {
-        stream.end();
+        writer?.stream.end();
     }
 }
 function printDebugHelp(cliName) {
@@ -1871,21 +2000,21 @@ function printDebugOptionGroup(entries) {
         console.log(`  ${label}${description}`);
     });
 }
-function resolveWaitFlag({ waitFlag, model, engine, }) {
+function resolveWaitFlag({ waitFlag, model, engine, reasoningMode, }) {
     if (waitFlag === true)
         return true;
     if (waitFlag === false)
         return false;
-    return defaultWaitPreference(model, engine);
+    return defaultWaitPreference(model, engine, reasoningMode);
 }
-function resolveRestartWaitPreference({ waitFlag, storedPreference, model, engine, }) {
+function resolveRestartWaitPreference({ waitFlag, storedPreference, model, engine, reasoningMode, }) {
     if (waitFlag === true)
         return true;
     if (waitFlag === false)
         return false;
     if (typeof storedPreference === "boolean")
         return storedPreference;
-    return defaultWaitPreference(model, engine);
+    return defaultWaitPreference(model, engine, reasoningMode);
 }
 function resolveEffectiveModelIdForRun(model, stored) {
     if (stored)

package/dist/docs-site/CNAME

@@ -0,0 +1 @@
+askoracle.sh