@steipete/oracle 1.2.0 → 1.3.0

package/README.md

@@ -21,7 +21,10 @@ Oracle gives your agents a simple, reliable way to **bundle a prompt plus the ri
 If you omit `--engine`, Oracle prefers the API engine when `OPENAI_API_KEY` is present; otherwise it falls back to browser mode. Switch explicitly with `-e, --engine {api|browser}` when you want to override the auto choice. Everything else (prompt assembly, file handling, session logging) stays the same.
 
 Note: Browser engine is considered experimental, requires an OpenAI Pro account and only works on macOS with Chrome.
-Your system password is needed to copy cookies. API engine is stable and should be preferred.
+Windows/Linux browser support is in progress; until then, use `--engine api` or bundle files and paste manually.
+Your system password is needed to copy cookies. To skip Chrome/Keychain entirely, pass inline cookies via
+`--browser-inline-cookies <json|base64>` or `--browser-inline-cookies-file <path>` (fallback files at
+`~/.oracle/cookies.json` or `~/.oracle/cookies.base64`). API engine is stable and should be preferred.
 
 ## Quick start
 
@@ -38,6 +41,12 @@ npx -y @steipete/oracle -p "Review the TS data layer" --file "src/**/*.ts" --fil
 # Mixed glob + single file
 npx -y @steipete/oracle -p "Audit data layer" --file "src/**/*.ts" --file README.md
 
+# Dry-run (no API call) with summary estimate
+oracle --dry-run summary -p "Check release notes" --file docs/release-notes.md
+
+# Alternate base URL (LiteLLM, Azure, self-hosted gateways)
+OPENAI_API_KEY=sk-... oracle --base-url https://litellm.example.com/v1 -p "Summarize the risk register"
+
 # Inspect past sessions
 oracle status --clear --hours 168   # prune a week of cached runs
 oracle status                       # list runs; grab an ID
@@ -86,13 +95,12 @@ Put per-user defaults in `~/.oracle/config.json` (parsed as JSON5, so comments/t
 | `-f, --file <paths...>` | Attach files/dirs (supports globs and `!` excludes). |
 | `-e, --engine <api\|browser>` | Choose API or browser automation. Omitted: API when `OPENAI_API_KEY` is set, otherwise browser. |
 | `-m, --model <name>` | `gpt-5-pro` (default) or `gpt-5.1`. |
+| `--base-url <url>` | Point the API engine at any OpenAI-compatible endpoint (LiteLLM, Azure, etc.). |
+| `--azure-endpoint <url>` | Use Azure OpenAI (switches client automatically). |
 | `--files-report` | Print per-file token usage. |
-| `--preview [summary\|json\|full]` | Inspect the request without sending. |
-| `--render-markdown` | Print the assembled `[SYSTEM]/[USER]/[FILE]` bundle. |
-| `--wait` / `--no-wait` | Block until completion. Default: `wait` for gpt-5.1/browser; `no-wait` for gpt-5-pro API (reattach later). |
-| `-v, --verbose` | Extra logging (also surfaces advanced flags with `--help`). |
+| `--dry-run [summary\|json\|full]` | Inspect the request without sending (alias: `--preview`). |
 
-More knobs (`--max-input`, cookie sync controls for browser mode, etc.) live behind `oracle --help --verbose`.
+See [docs/openai-endpoints.md](docs/openai-endpoints.md) for advanced Azure/LiteLLM configuration.
 
 ## Sessions & background runs
 

package/dist/bin/oracle-cli.js

@@ -2,19 +2,22 @@
 import 'dotenv/config';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { once } from 'node:events';
 import { Command, Option } from 'commander';
 import { resolveEngine, defaultWaitPreference } from '../src/cli/engine.js';
 import { shouldRequirePrompt } from '../src/cli/promptRequirement.js';
 import chalk from 'chalk';
 import { ensureSessionStorage, initializeSession, readSessionMetadata, createSessionLogWriter, deleteSessionsOlderThan, } from '../src/sessionManager.js';
-import { runOracle, renderPromptMarkdown, readFiles } from '../src/oracle.js';
+import { renderPromptMarkdown, readFiles } from '../src/oracle.js';
 import { CHATGPT_URL } from '../src/browserMode.js';
 import { applyHelpStyling } from '../src/cli/help.js';
-import { collectPaths, parseFloatOption, parseIntOption, parseSearchOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, } from '../src/cli/options.js';
+import { collectPaths, parseFloatOption, parseIntOption, parseSearchOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, normalizeBaseUrl, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, parseTimeoutOption, } from '../src/cli/options.js';
+import { shouldDetachSession } from '../src/cli/detach.js';
 import { applyHiddenAliases } from '../src/cli/hiddenAliases.js';
 import { buildBrowserConfig, resolveBrowserModelLabel } from '../src/cli/browserConfig.js';
 import { performSessionRun } from '../src/cli/sessionRunner.js';
 import { attachSession, showStatus, formatCompletionSummary } from '../src/cli/sessionDisplay.js';
+import { resolveGeminiModelId } from '../src/oracle/gemini.js';
 import { handleSessionCommand, formatSessionCleanupMessage } from '../src/cli/sessionCommand.js';
 import { isErrorLogged } from '../src/cli/errorUtils.js';
 import { handleSessionAlias, handleStatusFlag } from '../src/cli/rootAlias.js';
@@ -76,10 +79,17 @@ program
     .addOption(new Option('--[no-]notify', 'Desktop notification when a session finishes (default on unless CI/SSH).')
     .default(undefined))
     .addOption(new Option('--[no-]notify-sound', 'Play a notification sound on completion (default off).').default(undefined))
-    .option('--dry-run', 'Validate inputs and show token estimates without calling the model.', false)
-    .addOption(new Option('--preview [mode]', 'Preview the request without calling the API (summary | json | full).')
+    .addOption(new Option('--timeout <seconds|auto>', 'Overall timeout before aborting the API call (auto = 20m for gpt-5-pro, 30s otherwise).')
+    .argParser(parseTimeoutOption)
+    .default('auto'))
+    .addOption(new Option('--preview [mode]', '(alias) Preview the request without calling the model (summary | json | full). Deprecated: use --dry-run instead.')
+    .hideHelp()
     .choices(['summary', 'json', 'full'])
     .preset('summary'))
+    .addOption(new Option('--dry-run [mode]', 'Preview without calling the model (summary | json | full).')
+    .choices(['summary', 'json', 'full'])
+    .preset('summary')
+    .default(false))
     .addOption(new Option('--exec-session <id>').hideHelp())
     .addOption(new Option('--session <id>').hideHelp())
     .addOption(new Option('--status', 'Show stored sessions (alias for `oracle status`).').default(false).hideHelp())
@@ -94,12 +104,19 @@ program
     .addOption(new Option('--max-output <tokens>', 'Override the max output tokens for the selected model.')
     .argParser(parseIntOption)
     .hideHelp())
+    .option('--base-url <url>', 'Override the OpenAI-compatible base URL for API runs (e.g. LiteLLM proxy endpoint).')
+    .option('--azure-endpoint <url>', 'Azure OpenAI Endpoint (e.g. https://resource.openai.azure.com/).')
+    .option('--azure-deployment <name>', 'Azure OpenAI Deployment Name.')
+    .option('--azure-api-version <version>', 'Azure OpenAI API Version.')
     .addOption(new Option('--browser', '(deprecated) Use --engine browser instead.').default(false).hideHelp())
     .addOption(new Option('--browser-chrome-profile <name>', 'Chrome profile name/path for cookie reuse.').hideHelp())
     .addOption(new Option('--browser-chrome-path <path>', 'Explicit Chrome or Chromium executable path.').hideHelp())
     .addOption(new Option('--browser-url <url>', `Override the ChatGPT URL (default ${CHATGPT_URL}).`).hideHelp())
     .addOption(new Option('--browser-timeout <ms|s|m>', 'Maximum time to wait for an answer (default 900s).').hideHelp())
     .addOption(new Option('--browser-input-timeout <ms|s|m>', 'Maximum time to wait for the prompt textarea (default 30s).').hideHelp())
+    .addOption(new Option('--browser-cookie-names <names>', 'Comma-separated cookie allowlist for sync.').hideHelp())
+    .addOption(new Option('--browser-inline-cookies <jsonOrBase64>', 'Inline cookies payload (JSON array or base64-encoded JSON).').hideHelp())
+    .addOption(new Option('--browser-inline-cookies-file <path>', 'Load inline cookies from file (JSON or base64 JSON).').hideHelp())
     .addOption(new Option('--browser-no-cookie-sync', 'Skip copying cookies from Chrome.').hideHelp())
     .addOption(new Option('--browser-headless', 'Launch Chrome in headless mode.').hideHelp())
     .addOption(new Option('--browser-hide-window', 'Hide the Chrome window after launch (macOS headful only).').hideHelp())
@@ -188,20 +205,32 @@ function buildRunOptions(options, overrides = {}) {
     if (!options.prompt) {
         throw new Error('Prompt is required.');
     }
+    const normalizedBaseUrl = normalizeBaseUrl(overrides.baseUrl ?? options.baseUrl);
+    const azure = options.azureEndpoint || overrides.azure?.endpoint
+        ? {
+            endpoint: overrides.azure?.endpoint ?? options.azureEndpoint,
+            deployment: overrides.azure?.deployment ?? options.azureDeployment,
+            apiVersion: overrides.azure?.apiVersion ?? options.azureApiVersion,
+        }
+        : undefined;
     return {
         prompt: options.prompt,
         model: options.model,
+        effectiveModelId: overrides.effectiveModelId ?? options.effectiveModelId ?? options.model,
         file: overrides.file ?? options.file ?? [],
         slug: overrides.slug ?? options.slug,
         filesReport: overrides.filesReport ?? options.filesReport,
         maxInput: overrides.maxInput ?? options.maxInput,
         maxOutput: overrides.maxOutput ?? options.maxOutput,
         system: overrides.system ?? options.system,
+        timeoutSeconds: overrides.timeoutSeconds ?? options.timeout,
         silent: overrides.silent ?? options.silent,
         search: overrides.search ?? options.search,
         preview: overrides.preview ?? undefined,
         previewMode: overrides.previewMode ?? options.previewMode,
         apiKey: overrides.apiKey ?? options.apiKey,
+        baseUrl: normalizedBaseUrl,
+        azure,
         sessionId: overrides.sessionId ?? options.sessionId,
         verbose: overrides.verbose ?? options.verbose,
         heartbeatIntervalMs: overrides.heartbeatIntervalMs ?? resolveHeartbeatIntervalMs(options.heartbeat),
@@ -227,6 +256,7 @@ function buildRunOptionsFromMetadata(metadata) {
     return {
         prompt: stored.prompt ?? '',
         model: stored.model ?? 'gpt-5-pro',
+        effectiveModelId: stored.effectiveModelId ?? stored.model,
         file: stored.file ?? [],
         slug: stored.slug,
         filesReport: stored.filesReport,
@@ -238,6 +268,8 @@ function buildRunOptionsFromMetadata(metadata) {
         preview: false,
         previewMode: undefined,
         apiKey: undefined,
+        baseUrl: normalizeBaseUrl(stored.baseUrl),
+        azure: stored.azure,
         sessionId: metadata.id,
         verbose: stored.verbose,
         heartbeatIntervalMs: stored.heartbeatIntervalMs,
@@ -253,8 +285,18 @@ function getBrowserConfigFromMetadata(metadata) {
     return metadata.options?.browserConfig ?? metadata.browser?.config;
 }
 async function runRootCommand(options) {
+    if (process.env.ORACLE_FORCE_TUI === '1') {
+        await ensureSessionStorage();
+        await launchTui({ version: VERSION });
+        return;
+    }
     const userConfig = (await loadUserConfig()).config;
     const helpRequested = rawCliArgs.some((arg) => arg === '--help' || arg === '-h');
+    const optionUsesDefault = (name) => {
+        // Commander reports undefined for untouched options, so treat undefined/default the same
+        const source = program.getOptionValueSource?.(name);
+        return source == null || source === 'default';
+    };
     if (helpRequested) {
         if (options.verbose) {
             console.log('');
@@ -264,7 +306,7 @@ async function runRootCommand(options) {
         program.help({ error: false });
         return;
     }
-    const previewMode = resolvePreviewMode(options.preview);
+    const previewMode = resolvePreviewMode(options.dryRun || options.preview);
     if (userCliArgs.length === 0) {
         if (tuiEnabled()) {
             await launchTui({ version: VERSION });
@@ -278,32 +320,68 @@ async function runRootCommand(options) {
         printDebugHelp(program.name());
         return;
     }
-    if (options.dryRun && previewMode) {
-        throw new Error('--dry-run cannot be combined with --preview.');
-    }
     if (options.dryRun && options.renderMarkdown) {
         throw new Error('--dry-run cannot be combined with --render-markdown.');
     }
     const preferredEngine = options.engine ?? userConfig.engine;
-    const engine = resolveEngine({ engine: preferredEngine, browserFlag: options.browser, env: process.env });
+    let engine = resolveEngine({ engine: preferredEngine, browserFlag: options.browser, env: process.env });
     if (options.browser) {
         console.log(chalk.yellow('`--browser` is deprecated; use `--engine browser` instead.'));
     }
-    if (program.getOptionValueSource?.('model') === 'default' && userConfig.model) {
+    if (optionUsesDefault('model') && userConfig.model) {
         options.model = userConfig.model;
     }
-    if (program.getOptionValueSource?.('search') === 'default' && userConfig.search) {
+    if (optionUsesDefault('search') && userConfig.search) {
         options.search = userConfig.search === 'on';
     }
-    if (program.getOptionValueSource?.('filesReport') === 'default' && userConfig.filesReport != null) {
+    if (optionUsesDefault('filesReport') && userConfig.filesReport != null) {
         options.filesReport = Boolean(userConfig.filesReport);
     }
-    if (program.getOptionValueSource?.('heartbeat') === 'default' && typeof userConfig.heartbeatSeconds === 'number') {
+    if (optionUsesDefault('heartbeat') && typeof userConfig.heartbeatSeconds === 'number') {
         options.heartbeat = userConfig.heartbeatSeconds;
     }
+    if (optionUsesDefault('baseUrl') && userConfig.apiBaseUrl) {
+        options.baseUrl = userConfig.apiBaseUrl;
+    }
+    if (optionUsesDefault('azureEndpoint')) {
+        if (process.env.AZURE_OPENAI_ENDPOINT) {
+            options.azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
+        }
+        else if (userConfig.azure?.endpoint) {
+            options.azureEndpoint = userConfig.azure.endpoint;
+        }
+    }
+    if (optionUsesDefault('azureDeployment')) {
+        if (process.env.AZURE_OPENAI_DEPLOYMENT) {
+            options.azureDeployment = process.env.AZURE_OPENAI_DEPLOYMENT;
+        }
+        else if (userConfig.azure?.deployment) {
+            options.azureDeployment = userConfig.azure.deployment;
+        }
+    }
+    if (optionUsesDefault('azureApiVersion')) {
+        if (process.env.AZURE_OPENAI_API_VERSION) {
+            options.azureApiVersion = process.env.AZURE_OPENAI_API_VERSION;
+        }
+        else if (userConfig.azure?.apiVersion) {
+            options.azureApiVersion = userConfig.azure.apiVersion;
+        }
+    }
     const cliModelArg = normalizeModelOption(options.model) || 'gpt-5-pro';
-    const resolvedModel = engine === 'browser' ? inferModelFromLabel(cliModelArg) : resolveApiModel(cliModelArg);
+    const resolvedModelCandidate = engine === 'browser' ? inferModelFromLabel(cliModelArg) : resolveApiModel(cliModelArg);
+    const isGemini = resolvedModelCandidate.startsWith('gemini');
+    const userForcedBrowser = options.browser || options.engine === 'browser';
+    if (isGemini && userForcedBrowser) {
+        throw new Error('Gemini is only supported via API. Use --engine api.');
+    }
+    if (isGemini && engine === 'browser') {
+        engine = 'api';
+    }
+    const resolvedModel = isGemini ? resolveApiModel(cliModelArg) : resolvedModelCandidate;
+    const effectiveModelId = resolvedModel.startsWith('gemini') ? resolveGeminiModelId(resolvedModel) : resolvedModel;
+    const resolvedBaseUrl = normalizeBaseUrl(options.baseUrl ?? process.env.OPENAI_BASE_URL);
     const resolvedOptions = { ...options, model: resolvedModel };
+    resolvedOptions.baseUrl = resolvedBaseUrl;
     // Decide whether to block until completion:
     // - explicit --wait / --no-wait wins
     // - otherwise block for fast models (gpt-5.1, browser) and detach by default for gpt-5-pro API
@@ -333,13 +411,13 @@ async function runRootCommand(options) {
     }
     if (previewMode) {
         if (!options.prompt) {
-            throw new Error('Prompt is required when using --preview.');
+            throw new Error('Prompt is required when using --dry-run/preview.');
         }
         if (userConfig.promptSuffix) {
             options.prompt = `${options.prompt.trim()}\n${userConfig.promptSuffix}`;
         }
         resolvedOptions.prompt = options.prompt;
-        const runOptions = buildRunOptions(resolvedOptions, { preview: true, previewMode });
+        const runOptions = buildRunOptions(resolvedOptions, { preview: true, previewMode, baseUrl: resolvedBaseUrl });
         if (engine === 'browser') {
             await runBrowserPreview({
                 runOptions,
@@ -350,7 +428,24 @@ async function runRootCommand(options) {
             }, {});
             return;
         }
-        await runOracle(runOptions, { log: console.log, write: (chunk) => process.stdout.write(chunk) });
+        // API dry-run/preview path
+        if (previewMode === 'summary') {
+            await runDryRunSummary({
+                engine,
+                runOptions,
+                cwd: process.cwd(),
+                version: VERSION,
+                log: console.log,
+            }, {});
+            return;
+        }
+        await runDryRunSummary({
+            engine,
+            runOptions,
+            cwd: process.cwd(),
+            version: VERSION,
+            log: console.log,
+        }, {});
         return;
     }
     if (!options.prompt) {
@@ -360,17 +455,6 @@ async function runRootCommand(options) {
         options.prompt = `${options.prompt.trim()}\n${userConfig.promptSuffix}`;
     }
     resolvedOptions.prompt = options.prompt;
-    if (options.dryRun) {
-        const baseRunOptions = buildRunOptions(resolvedOptions, { preview: false, previewMode: undefined });
-        await runDryRunSummary({
-            engine,
-            runOptions: baseRunOptions,
-            cwd: process.cwd(),
-            version: VERSION,
-            log: console.log,
-        }, {});
-        return;
-    }
     if (options.file && options.file.length > 0) {
         await readFiles(options.file, { cwd: process.cwd() });
     }
@@ -384,17 +468,34 @@ async function runRootCommand(options) {
     const sessionMode = engine === 'browser' ? 'browser' : 'api';
     const browserModelLabelOverride = sessionMode === 'browser' ? resolveBrowserModelLabel(cliModelArg, resolvedModel) : undefined;
     const browserConfig = sessionMode === 'browser'
-        ? buildBrowserConfig({
+        ? await buildBrowserConfig({
             ...options,
             model: resolvedModel,
             browserModelLabel: browserModelLabelOverride,
         })
         : undefined;
+    if (options.dryRun) {
+        const baseRunOptions = buildRunOptions(resolvedOptions, {
+            preview: false,
+            previewMode: undefined,
+            baseUrl: resolvedBaseUrl,
+        });
+        await runDryRunSummary({
+            engine,
+            runOptions: baseRunOptions,
+            cwd: process.cwd(),
+            version: VERSION,
+            log: console.log,
+            browserConfig,
+        }, {});
+        return;
+    }
     await ensureSessionStorage();
     const baseRunOptions = buildRunOptions(resolvedOptions, {
         preview: false,
         previewMode: undefined,
         background: userConfig.background ?? resolvedOptions.background,
+        baseUrl: resolvedBaseUrl,
     });
     enforceBrowserSearchFlag(baseRunOptions, sessionMode, console.log);
     if (sessionMode === 'browser' && baseRunOptions.search === false) {
@@ -406,12 +507,19 @@ async function runRootCommand(options) {
         mode: sessionMode,
         browserConfig,
     }, process.cwd(), notifications);
-    const reattachCommand = `pnpm oracle session ${sessionMeta.id}`;
-    console.log(chalk.bold(`Reattach later with: ${chalk.cyan(reattachCommand)}`));
-    console.log('');
-    const liveRunOptions = { ...baseRunOptions, sessionId: sessionMeta.id };
-    const disableDetach = process.env.ORACLE_NO_DETACH === '1';
-    const detached = disableDetach
+    const liveRunOptions = {
+        ...baseRunOptions,
+        sessionId: sessionMeta.id,
+        effectiveModelId,
+    };
+    const disableDetachEnv = process.env.ORACLE_NO_DETACH === '1';
+    const detachAllowed = shouldDetachSession({
+        engine,
+        model: resolvedModel,
+        waitPreference,
+        disableDetachEnv,
+    });
+    const detached = !detachAllowed
         ? false
         : await launchDetachedSession(sessionMeta.id).catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
@@ -429,17 +537,15 @@ async function runRootCommand(options) {
         return;
     }
     if (detached === false) {
-        await runInteractiveSession(sessionMeta, liveRunOptions, sessionMode, browserConfig, true, notifications, userConfig);
-        console.log(chalk.bold(`Session ${sessionMeta.id} completed`));
+        await runInteractiveSession(sessionMeta, liveRunOptions, sessionMode, browserConfig, false, notifications, userConfig, true);
         return;
     }
     if (detached) {
         console.log(chalk.blue(`Reattach via: oracle session ${sessionMeta.id}`));
         await attachSession(sessionMeta.id, { suppressMetadata: true });
-        console.log(chalk.bold(`Session ${sessionMeta.id} completed`));
     }
 }
-async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfig, showReattachHint = true, notifications, userConfig) {
+async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfig, showReattachHint = true, notifications, userConfig, suppressSummary = false) {
     const { logLine, writeChunk, stream } = createSessionLogWriter(sessionMeta.id);
     let headerAugmented = false;
     const combinedLog = (message = '') => {
@@ -474,10 +580,12 @@ async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfi
             notifications: notifications ?? deriveNotificationSettingsFromMetadata(sessionMeta, process.env, userConfig?.notify),
         });
         const latest = await readSessionMetadata(sessionMeta.id);
-        const summary = latest ? formatCompletionSummary(latest, { includeSlug: true }) : null;
-        if (summary) {
-            console.log('\n' + chalk.green.bold(summary));
-            logLine(summary); // plain text in log, colored on stdout
+        if (!suppressSummary) {
+            const summary = latest ? formatCompletionSummary(latest, { includeSlug: true }) : null;
+            if (summary) {
+                console.log('\n' + chalk.green.bold(summary));
+                logLine(summary); // plain text in log, colored on stdout
+            }
         }
     }
     catch (error) {
@@ -611,7 +719,16 @@ program.action(async function () {
     const options = this.optsWithGlobals();
     await runRootCommand(options);
 });
-await program.parseAsync(process.argv).catch((error) => {
+async function main() {
+    const parsePromise = program.parseAsync(process.argv);
+    const sigintPromise = once(process, 'SIGINT').then(() => 'sigint');
+    const result = await Promise.race([parsePromise.then(() => 'parsed'), sigintPromise]);
+    if (result === 'sigint') {
+        console.log(chalk.yellow('\nCancelled.'));
+        process.exitCode = 130;
+    }
+}
+void main().catch((error) => {
     if (error instanceof Error) {
         if (!isErrorLogged(error)) {
             console.error(chalk.red('✖'), error.message);

package/dist/src/browser/config.js

@@ -6,6 +6,9 @@ export const DEFAULT_BROWSER_CONFIG = {
     timeoutMs: 900_000,
     inputTimeoutMs: 30_000,
     cookieSync: true,
+    cookieNames: null,
+    inlineCookies: null,
+    inlineCookiesSource: null,
     headless: false,
     keepBrowser: false,
     hideWindow: false,
@@ -21,6 +24,9 @@ export function resolveBrowserConfig(config) {
         timeoutMs: config?.timeoutMs ?? DEFAULT_BROWSER_CONFIG.timeoutMs,
         inputTimeoutMs: config?.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs,
         cookieSync: config?.cookieSync ?? DEFAULT_BROWSER_CONFIG.cookieSync,
+        cookieNames: config?.cookieNames ?? DEFAULT_BROWSER_CONFIG.cookieNames,
+        inlineCookies: config?.inlineCookies ?? DEFAULT_BROWSER_CONFIG.inlineCookies,
+        inlineCookiesSource: config?.inlineCookiesSource ?? DEFAULT_BROWSER_CONFIG.inlineCookiesSource,
         headless: config?.headless ?? DEFAULT_BROWSER_CONFIG.headless,
         keepBrowser: config?.keepBrowser ?? DEFAULT_BROWSER_CONFIG.keepBrowser,
         hideWindow: config?.hideWindow ?? DEFAULT_BROWSER_CONFIG.hideWindow,

package/dist/src/browser/cookies.js

@@ -4,21 +4,18 @@ import { fileURLToPath } from 'node:url';
 import { COOKIE_URLS } from './constants.js';
 export class ChromeCookieSyncError extends Error {
 }
-export async function syncCookies(Network, url, profile, logger, allowErrors = false) {
+export async function syncCookies(Network, url, profile, logger, options = {}) {
+    const { allowErrors = false, filterNames, inlineCookies } = options;
     try {
-        const cookies = await readChromeCookies(url, profile);
+        const cookies = inlineCookies?.length
+            ? normalizeInlineCookies(inlineCookies, new URL(url).hostname)
+            : await readChromeCookies(url, profile, filterNames ?? undefined);
         if (!cookies.length) {
             return 0;
         }
         let applied = 0;
         for (const cookie of cookies) {
-            const cookieWithUrl = { ...cookie };
-            if (!cookieWithUrl.domain || cookieWithUrl.domain === 'localhost') {
-                cookieWithUrl.url = url;
-            }
-            else if (!cookieWithUrl.domain.startsWith('.')) {
-                cookieWithUrl.url = `https://${cookieWithUrl.domain}`;
-            }
+            const cookieWithUrl = attachUrl(cookie, url);
             try {
                 const result = await Network.setCookie(cookieWithUrl);
                 if (result?.success) {
@@ -41,10 +38,11 @@ export async function syncCookies(Network, url, profile, logger, allowErrors = f
         throw error instanceof ChromeCookieSyncError ? error : new ChromeCookieSyncError(message);
     }
 }
-async function readChromeCookies(url, profile) {
+async function readChromeCookies(url, profile, filterNames) {
     const chromeModule = await loadChromeCookiesModule();
     const urlsToCheck = Array.from(new Set([stripQuery(url), ...COOKIE_URLS]));
     const merged = new Map();
+    const allowlist = normalizeCookieNames(filterNames);
     for (const candidateUrl of urlsToCheck) {
         let rawCookies;
         rawCookies = await chromeModule.getCookiesPromised(candidateUrl, 'puppeteer', profile ?? undefined);
@@ -54,7 +52,7 @@ async function readChromeCookies(url, profile) {
         const fallbackHostname = new URL(candidateUrl).hostname;
         for (const cookie of rawCookies) {
             const normalized = normalizeCookie(cookie, fallbackHostname);
-            if (!normalized) {
+            if (!normalized || (allowlist && !allowlist.has(normalized.name))) {
                 continue;
             }
             const key = `${normalized.domain ?? fallbackHostname}:${normalized.name}`;
@@ -83,6 +81,46 @@ function normalizeCookie(cookie, fallbackHost) {
         httpOnly,
     };
 }
+function normalizeInlineCookies(rawCookies, fallbackHost) {
+    const merged = new Map();
+    for (const cookie of rawCookies) {
+        if (!cookie?.name)
+            continue;
+        const normalized = {
+            ...cookie,
+            name: cookie.name,
+            value: cookie.value ?? '',
+            domain: cookie.domain ?? fallbackHost,
+            path: cookie.path ?? '/',
+            expires: normalizeExpiration(cookie.expires),
+            secure: cookie.secure ?? true,
+            httpOnly: cookie.httpOnly ?? false,
+        };
+        const key = `${normalized.domain ?? fallbackHost}:${normalized.name}`;
+        if (!merged.has(key)) {
+            merged.set(key, normalized);
+        }
+    }
+    return Array.from(merged.values());
+}
+function normalizeCookieNames(names) {
+    if (!names || names.length === 0) {
+        return null;
+    }
+    return new Set(names.map((name) => name.trim()).filter(Boolean));
+}
+function attachUrl(cookie, fallbackUrl) {
+    const cookieWithUrl = { ...cookie };
+    if (!cookieWithUrl.url) {
+        if (!cookieWithUrl.domain || cookieWithUrl.domain === 'localhost') {
+            cookieWithUrl.url = fallbackUrl;
+        }
+        else if (!cookieWithUrl.domain.startsWith('.')) {
+            cookieWithUrl.url = `https://${cookieWithUrl.domain}`;
+        }
+    }
+    return cookieWithUrl;
+}
 function stripQuery(url) {
     try {
         const parsed = new URL(url);

package/dist/src/browser/index.js

@@ -64,11 +64,24 @@ export async function runBrowserMode(options) {
         await Promise.all(domainEnablers);
         await Network.clearBrowserCookies();
         if (config.cookieSync) {
-            logger('Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; approve it to stay signed in or rerun with --browser-no-cookie-sync / --browser-allow-cookie-errors.');
-            const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, config.allowCookieErrors ?? false);
+            if (!config.inlineCookies) {
+                logger('Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; approve it to stay signed in or rerun with --browser-no-cookie-sync / --browser-allow-cookie-errors / --browser-inline-cookies[(-file)]. Inline cookies skip Chrome + Keychain entirely.');
+            }
+            else {
+                logger('Applying inline cookies (skipping Chrome profile read and Keychain prompt)');
+            }
+            const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, {
+                allowErrors: config.allowCookieErrors ?? false,
+                filterNames: config.cookieNames ?? undefined,
+                inlineCookies: config.inlineCookies ?? undefined,
+            });
             logger(cookieCount > 0
-                ? `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
-                : 'No Chrome cookies found; continuing without session reuse');
+                ? config.inlineCookies
+                    ? `Applied ${cookieCount} inline cookies`
+                    : `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
+                : config.inlineCookies
+                    ? 'No inline cookies applied; continuing without session reuse'
+                    : 'No Chrome cookies found; continuing without session reuse');
         }
         else {
             logger('Skipping Chrome cookie sync (--browser-no-cookie-sync)');
@@ -212,7 +225,7 @@ export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
         .toString()
         .padStart(3, ' ');
     const statusLabel = message ? ` — ${message}` : '';
-    return `[${elapsedText} / ~10m] ${bar} ${pct}%${statusLabel}${locatorSuffix}`;
+    return `${bar} ${pct}% [${elapsedText} / ~10m]${statusLabel}${locatorSuffix}`;
 }
 function startThinkingStatusMonitor(Runtime, logger, includeDiagnostics = false) {
     let stopped = false;

package/dist/src/browser/sessionRunner.js

@@ -4,6 +4,11 @@ import { runBrowserMode } from '../browserMode.js';
 import { assembleBrowserPrompt } from './prompt.js';
 import { BrowserAutomationError } from '../oracle/errors.js';
 export async function runBrowserSessionExecution({ runOptions, browserConfig, cwd, log, cliVersion }, deps = {}) {
+    if (runOptions.model.startsWith('gemini')) {
+        throw new BrowserAutomationError('Gemini models are not available in browser mode. Re-run with --engine api.', {
+            stage: 'preflight',
+        });
+    }
     const assemblePrompt = deps.assemblePrompt ?? assembleBrowserPrompt;
     const executeBrowser = deps.executeBrowser ?? runBrowserMode;
     const promptArtifacts = await assemblePrompt(runOptions, { cwd });
@@ -24,6 +29,9 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         }
     }
     const headerLine = `oracle (${cliVersion}) launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens`;
+    if (promptArtifacts.bundled) {
+        log(chalk.yellow(`[browser] Packed ${promptArtifacts.bundled.originalCount} files into ${promptArtifacts.bundled.bundlePath}. If automation fails, you can drag this file into ChatGPT manually.`));
+    }
     const automationLogger = ((message) => {
         if (typeof message === 'string') {
             log(message);
@@ -64,7 +72,8 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         totalTokens: promptArtifacts.estimatedInputTokens + browserResult.answerTokens,
     };
     const tokensDisplay = `${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens}`;
-    const statsParts = [`${runOptions.model}[browser]`, `tok(i/o/r/t)=${tokensDisplay}`];
+    const tokensLabel = runOptions.verbose ? 'tokens (input/output/reasoning/total)' : 'tok(i/o/r/t)';
+    const statsParts = [`${runOptions.model}[browser]`, `${tokensLabel}=${tokensDisplay}`];
     if (runOptions.file && runOptions.file.length > 0) {
         statsParts.push(`files=${runOptions.file.length}`);
     }