@steipete/oracle 0.7.2 → 0.7.4

package/dist/src/browser/reattach.js

@@ -1,5 +1,13 @@
 import CDP from 'chrome-remote-interface';
-import { waitForAssistantResponse, captureAssistantMarkdown } from './pageActions.js';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdtemp, mkdir, rm } from 'node:fs/promises';
+import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, } from './pageActions.js';
+import { launchChrome, connectToChrome, hideChromeWindow } from './chromeLifecycle.js';
+import { resolveBrowserConfig } from './config.js';
+import { syncCookies } from './cookies.js';
+import { CHATGPT_URL } from './constants.js';
+import { delay } from './utils.js';
 function pickTarget(targets, runtime) {
     if (!Array.isArray(targets) || targets.length === 0) {
         return undefined;
@@ -18,33 +26,114 @@ function pickTarget(targets, runtime) {
     return targets.find((t) => t.type === 'page') ?? targets[0];
 }
 export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
+    const recoverSession = deps.recoverSession ??
+        (async (runtimeMeta, configMeta) => resumeBrowserSessionViaNewChrome(runtimeMeta, configMeta, logger, deps));
     if (!runtime.chromePort) {
-        throw new Error('Missing chromePort; cannot reattach.');
+        logger('No running Chrome detected; reopening browser to locate the session.');
+        return recoverSession(runtime, config);
     }
     const host = runtime.chromeHost ?? '127.0.0.1';
-    const listTargets = deps.listTargets ??
-        (async () => {
-            const targets = await CDP.List({ host, port: runtime.chromePort });
-            return targets;
-        });
-    const connect = deps.connect ?? ((options) => CDP(options));
-    const targetList = (await listTargets());
-    const target = pickTarget(targetList, runtime);
-    const client = (await connect({
-        host,
-        port: runtime.chromePort,
-        target: target?.targetId,
-    }));
-    const { Runtime, DOM } = client;
+    try {
+        const listTargets = deps.listTargets ??
+            (async () => {
+                const targets = await CDP.List({ host, port: runtime.chromePort });
+                return targets;
+            });
+        const connect = deps.connect ?? ((options) => CDP(options));
+        const targetList = (await listTargets());
+        const target = pickTarget(targetList, runtime);
+        const client = (await connect({
+            host,
+            port: runtime.chromePort,
+            target: target?.targetId,
+        }));
+        const { Runtime, DOM } = client;
+        if (Runtime?.enable) {
+            await Runtime.enable();
+        }
+        if (DOM && typeof DOM.enable === 'function') {
+            await DOM.enable();
+        }
+        const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
+        const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
+        const timeoutMs = config?.timeoutMs ?? 120_000;
+        const answer = await waitForResponse(Runtime, timeoutMs, logger);
+        const markdown = (await captureMarkdown(Runtime, answer.meta, logger)) ?? answer.text;
+        if (client && typeof client.close === 'function') {
+            try {
+                await client.close();
+            }
+            catch {
+                // ignore
+            }
+        }
+        return { answerText: answer.text, answerMarkdown: markdown };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Existing Chrome reattach failed (${message}); reopening browser to locate the session.`);
+        return recoverSession(runtime, config);
+    }
+}
+async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
+    const resolved = resolveBrowserConfig(config ?? {});
+    const manualLogin = Boolean(resolved.manualLogin);
+    const userDataDir = manualLogin
+        ? resolved.manualLoginProfileDir ?? path.join(os.homedir(), '.oracle', 'browser-profile')
+        : await mkdtemp(path.join(os.tmpdir(), 'oracle-reattach-'));
+    if (manualLogin) {
+        await mkdir(userDataDir, { recursive: true });
+    }
+    const chrome = await launchChrome(resolved, userDataDir, logger);
+    const chromeHost = chrome.host ?? '127.0.0.1';
+    const client = await connectToChrome(chrome.port, logger, chromeHost);
+    const { Network, Page, Runtime, DOM } = client;
     if (Runtime?.enable) {
         await Runtime.enable();
     }
     if (DOM && typeof DOM.enable === 'function') {
         await DOM.enable();
     }
+    if (!resolved.headless && resolved.hideWindow) {
+        await hideChromeWindow(chrome, logger);
+    }
+    let appliedCookies = 0;
+    if (!manualLogin && resolved.cookieSync) {
+        appliedCookies = await syncCookies(Network, resolved.url, resolved.chromeProfile, logger, {
+            allowErrors: resolved.allowCookieErrors,
+            filterNames: resolved.cookieNames ?? undefined,
+            inlineCookies: resolved.inlineCookies ?? undefined,
+            cookiePath: resolved.chromeCookiePath ?? undefined,
+        });
+    }
+    await navigateToChatGPT(Page, Runtime, CHATGPT_URL, logger);
+    await ensureNotBlocked(Runtime, resolved.headless, logger);
+    await ensureLoggedIn(Runtime, logger, { appliedCookies });
+    if (resolved.url !== CHATGPT_URL) {
+        await navigateToChatGPT(Page, Runtime, resolved.url, logger);
+        await ensureNotBlocked(Runtime, resolved.headless, logger);
+    }
+    await ensurePromptReady(Runtime, resolved.inputTimeoutMs, logger);
+    const conversationUrl = buildConversationUrl(runtime, resolved.url);
+    if (conversationUrl) {
+        logger(`Reopening conversation at ${conversationUrl}`);
+        await navigateToChatGPT(Page, Runtime, conversationUrl, logger);
+        await ensureNotBlocked(Runtime, resolved.headless, logger);
+        await ensurePromptReady(Runtime, resolved.inputTimeoutMs, logger);
+    }
+    else {
+        const opened = await openConversationFromSidebar(Runtime, {
+            conversationId: runtime.conversationId ?? extractConversationIdFromUrl(runtime.tabUrl ?? ''),
+            preferProjects: resolved.url !== CHATGPT_URL,
+        });
+        if (!opened) {
+            throw new Error('Unable to locate prior ChatGPT conversation in sidebar.');
+        }
+        await waitForLocationChange(Runtime, 15_000);
+    }
     const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
     const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
-    const timeoutMs = config?.timeoutMs ?? 120_000;
+    const timeoutMs = resolved.timeoutMs ?? 120_000;
     const answer = await waitForResponse(Runtime, timeoutMs, logger);
     const markdown = (await captureMarkdown(Runtime, answer.meta, logger)) ?? answer.text;
     if (client && typeof client.close === 'function') {
@@ -55,5 +144,91 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
             // ignore
         }
     }
+    if (!resolved.keepBrowser && !manualLogin) {
+        try {
+            await chrome.kill();
+        }
+        catch {
+            // ignore
+        }
+        await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+    }
     return { answerText: answer.text, answerMarkdown: markdown };
 }
+function extractConversationIdFromUrl(url) {
+    if (!url)
+        return undefined;
+    const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
+    return match?.[1];
+}
+function buildConversationUrl(runtime, baseUrl) {
+    if (runtime.tabUrl) {
+        return runtime.tabUrl;
+    }
+    const conversationId = runtime.conversationId;
+    if (!conversationId) {
+        return null;
+    }
+    try {
+        const base = new URL(baseUrl);
+        return `${base.origin}/c/${conversationId}`;
+    }
+    catch {
+        return null;
+    }
+}
+async function openConversationFromSidebar(Runtime, options) {
+    const response = await Runtime.evaluate({
+        expression: `(() => {
+      const conversationId = ${JSON.stringify(options.conversationId ?? null)};
+      const preferProjects = ${JSON.stringify(Boolean(options.preferProjects))};
+      const nav = document.querySelector('nav') || document.querySelector('aside') || document.body;
+      if (preferProjects) {
+        const projectLink = Array.from(nav.querySelectorAll('a,button'))
+          .find((el) => (el.textContent || '').trim().toLowerCase() === 'projects');
+        if (projectLink) {
+          projectLink.click();
+        }
+      }
+      const links = Array.from(nav.querySelectorAll('a[href]'))
+        .filter((el) => el instanceof HTMLAnchorElement)
+        .map((el) => el);
+      const convoLinks = links.filter((el) => el.href.includes('/c/'));
+      let target = null;
+      if (conversationId) {
+        target = convoLinks.find((el) => el.href.includes('/c/' + conversationId));
+      }
+      if (!target && convoLinks.length > 0) {
+        target = convoLinks[0];
+      }
+      if (target) {
+        target.scrollIntoView({ block: 'center' });
+        target.click();
+        return { ok: true, href: target.href, count: convoLinks.length };
+      }
+      return { ok: false, count: convoLinks.length };
+    })()`,
+        returnByValue: true,
+    });
+    return Boolean(response.result?.value?.ok);
+}
+async function waitForLocationChange(Runtime, timeoutMs) {
+    const start = Date.now();
+    let lastHref = '';
+    while (Date.now() - start < timeoutMs) {
+        const { result } = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
+        const href = typeof result?.value === 'string' ? result.value : '';
+        if (lastHref && href !== lastHref) {
+            return;
+        }
+        lastHref = href;
+        await delay(200);
+    }
+}
+// biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
+export const __test__ = {
+    pickTarget,
+    extractConversationIdFromUrl,
+    buildConversationUrl,
+    openConversationFromSidebar,
+};

package/dist/src/cli/browserConfig.js

@@ -5,17 +5,20 @@ import { getOracleHomeDir } from '../oracleHome.js';
 const DEFAULT_BROWSER_TIMEOUT_MS = 1_200_000;
 const DEFAULT_BROWSER_INPUT_TIMEOUT_MS = 30_000;
 const DEFAULT_CHROME_PROFILE = 'Default';
-const BROWSER_MODEL_LABELS = {
-    // Browser engine supports GPT-5.2 and GPT-5.2 Pro (legacy/Pro aliases normalize to those targets).
-    'gpt-5-pro': 'GPT-5.2 Pro',
-    'gpt-5.1-pro': 'GPT-5.2 Pro',
-    'gpt-5.1': 'GPT-5.2',
-    'gpt-5.2': 'GPT-5.2',
-    // ChatGPT UI doesn't expose "instant" as a separate picker option; treat it as GPT-5.2 for browser automation.
-    'gpt-5.2-instant': 'GPT-5.2',
-    'gpt-5.2-pro': 'GPT-5.2 Pro',
-    'gemini-3-pro': 'Gemini 3 Pro',
-};
+// Ordered array: most specific models first to ensure correct selection.
+// The browser label is passed to the model picker which fuzzy-matches against ChatGPT's UI.
+const BROWSER_MODEL_LABELS = [
+    // Most specific first (e.g., "gpt-5.2-thinking" before "gpt-5.2")
+    ['gpt-5.2-thinking', 'GPT-5.2 Thinking'],
+    ['gpt-5.2-instant', 'GPT-5.2 Instant'],
+    ['gpt-5.2-pro', 'GPT-5.2 Pro'],
+    ['gpt-5.1-pro', 'GPT-5.2 Pro'],
+    ['gpt-5-pro', 'GPT-5.2 Pro'],
+    // Base models last (least specific)
+    ['gpt-5.2', 'GPT-5.2'], // Selects "Auto" in ChatGPT UI
+    ['gpt-5.1', 'GPT-5.2'], // Legacy alias → Auto
+    ['gemini-3-pro', 'Gemini 3 Pro'],
+];
 export function normalizeChatGptModelForBrowser(model) {
     const normalized = model.toLowerCase();
     if (!normalized.startsWith('gpt-') || normalized.includes('codex')) {
@@ -25,10 +28,11 @@ export function normalizeChatGptModelForBrowser(model) {
     if (normalized === 'gpt-5-pro' || normalized === 'gpt-5.1-pro' || normalized.endsWith('-pro')) {
         return 'gpt-5.2-pro';
     }
-    // Legacy / UI-mismatch variants: map to the closest ChatGPT picker target.
-    if (normalized === 'gpt-5.2-instant') {
-        return 'gpt-5.2';
+    // Explicit model variants: keep as-is (they have their own browser labels)
+    if (normalized === 'gpt-5.2-thinking' || normalized === 'gpt-5.2-instant') {
+        return normalized;
     }
+    // Legacy aliases: map to base GPT-5.2 (Auto)
     if (normalized === 'gpt-5.1') {
         return 'gpt-5.2';
     }
@@ -86,7 +90,7 @@ export async function buildBrowserConfig(options) {
         // Allow cookie failures by default so runs can continue without Chrome/Keychain secrets.
         allowCookieErrors: options.browserAllowCookieErrors ?? true,
         remoteChrome,
-        extendedThinking: options.browserExtendedThinking ? true : undefined,
+        thinkingTime: options.browserThinkingTime,
     };
 }
 function selectBrowserPort(options) {
@@ -100,7 +104,13 @@ function selectBrowserPort(options) {
 }
 export function mapModelToBrowserLabel(model) {
     const normalized = normalizeChatGptModelForBrowser(model);
-    return BROWSER_MODEL_LABELS[normalized] ?? DEFAULT_MODEL_TARGET;
+    // Iterate ordered array to find first match (most specific first)
+    for (const [key, label] of BROWSER_MODEL_LABELS) {
+        if (key === normalized) {
+            return label;
+        }
+    }
+    return DEFAULT_MODEL_TARGET;
 }
 export function resolveBrowserModelLabel(input, model) {
     const trimmed = input?.trim?.() ?? '';

package/dist/src/cli/notifier.js

@@ -2,6 +2,7 @@ import notifier from 'toasted-notifier';
 import { spawn } from 'node:child_process';
 import { formatUSD, formatNumber } from '../oracle/format.js';
 import { MODEL_CONFIGS } from '../oracle/config.js';
+import { estimateUsdCost } from 'tokentally';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createRequire } from 'node:module';
@@ -131,8 +132,13 @@ function inferCost(payload) {
     const config = MODEL_CONFIGS[model];
     if (!config?.pricing)
         return undefined;
-    return (usage.inputTokens * config.pricing.inputPerToken +
-        usage.outputTokens * config.pricing.outputPerToken);
+    return (estimateUsdCost({
+        usage: { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens },
+        pricing: {
+            inputUsdPerToken: config.pricing.inputPerToken,
+            outputUsdPerToken: config.pricing.outputPerToken,
+        },
+    })?.totalUsd ?? undefined);
 }
 function parseToggle(value) {
     if (value == null)

package/dist/src/cli/options.js

@@ -187,6 +187,13 @@ export function inferModelFromLabel(modelValue) {
     if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('pro')) {
         return 'gpt-5.2-pro';
     }
+    // Browser-only: pass through 5.2 thinking/instant variants for browser label mapping
+    if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('thinking')) {
+        return 'gpt-5.2-thinking';
+    }
+    if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('instant')) {
+        return 'gpt-5.2-instant';
+    }
     if (normalized.includes('5.0') || normalized.includes('5-pro')) {
         return 'gpt-5-pro';
     }
@@ -205,8 +212,11 @@ export function inferModelFromLabel(modelValue) {
     if (normalized.includes('5.1') || normalized.includes('5_1')) {
         return 'gpt-5.1';
     }
-    if (normalized.includes('instant') || normalized.includes('thinking') || normalized.includes('fast')) {
-        return 'gpt-5.1';
+    if (normalized.includes('thinking')) {
+        return 'gpt-5.2-thinking';
+    }
+    if (normalized.includes('instant') || normalized.includes('fast')) {
+        return 'gpt-5.2-instant';
     }
-    return 'gpt-5.1';
+    return 'gpt-5.2';
 }

package/dist/src/cli/oscUtils.js

@@ -1,20 +1,2 @@
 // Utilities for handling OSC progress codes embedded in stored logs.
-const OSC_PROGRESS_PREFIX = '\u001b]9;4;';
-const OSC_END = '\u001b\\';
-/**
- * Optionally removes OSC 9;4 progress sequences (used by Ghostty/WezTerm to show progress bars).
- * Keep them when replaying to a real TTY; strip when piping to non-TTY outputs.
- */
-export function sanitizeOscProgress(text, keepOsc) {
-    if (keepOsc) {
-        return text;
-    }
-    let current = text;
-    while (current.includes(OSC_PROGRESS_PREFIX)) {
-        const start = current.indexOf(OSC_PROGRESS_PREFIX);
-        const end = current.indexOf(OSC_END, start + OSC_PROGRESS_PREFIX.length);
-        const cutEnd = end === -1 ? start + OSC_PROGRESS_PREFIX.length : end + OSC_END.length;
-        current = `${current.slice(0, start)}${current.slice(cutEnd)}`;
-    }
-    return current;
-}
+export { sanitizeOscProgress } from 'osc-progress';

package/dist/src/cli/sessionDisplay.js

@@ -76,10 +76,13 @@ export async function attachSession(sessionId, options) {
     const isVerbose = Boolean(process.env.ORACLE_VERBOSE_RENDER);
     const runtime = metadata.browser?.runtime;
     const controllerAlive = isProcessAlive(runtime?.controllerPid);
-    const canReattach = metadata.status === 'running' &&
+    const hasChromeDisconnect = metadata.response?.incompleteReason === 'chrome-disconnected';
+    const statusAllowsReattach = metadata.status === 'running' || (metadata.status === 'error' && hasChromeDisconnect);
+    const hasFallbackSessionInfo = Boolean(runtime?.chromePort || runtime?.tabUrl || runtime?.conversationId);
+    const canReattach = statusAllowsReattach &&
         metadata.mode === 'browser' &&
-        runtime?.chromePort &&
-        (metadata.response?.incompleteReason === 'chrome-disconnected' || (runtime.controllerPid && !controllerAlive));
+        hasFallbackSessionInfo &&
+        (hasChromeDisconnect || (runtime?.controllerPid && !controllerAlive));
     if (canReattach) {
         const portInfo = runtime?.chromePort ? `port ${runtime.chromePort}` : 'unknown port';
         const urlInfo = runtime?.tabUrl ? `url=${runtime.tabUrl}` : 'url=unknown';

package/dist/src/cli/sessionTable.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import kleur from 'kleur';
 import { MODEL_CONFIGS } from '../oracle.js';
+import { estimateUsdCost } from 'tokentally';
 const isRich = (rich) => rich ?? Boolean(process.stdout.isTTY && chalk.level > 0);
 const dim = (text, rich) => (rich ? kleur.dim(text) : text);
 export const STATUS_PAD = 9;
@@ -48,7 +49,10 @@ export function resolveSessionCost(meta) {
     }
     const input = meta.usage.inputTokens ?? 0;
     const output = meta.usage.outputTokens ?? 0;
-    const cost = input * pricing.inputPerToken + output * pricing.outputPerToken;
+    const cost = estimateUsdCost({
+        usage: { inputTokens: input, outputTokens: output },
+        pricing: { inputUsdPerToken: pricing.inputPerToken, outputUsdPerToken: pricing.outputPerToken },
+    })?.totalUsd ?? 0;
     return cost > 0 ? cost : null;
 }
 export function formatTimestampAligned(iso) {

package/dist/src/oracle/files.js

@@ -13,7 +13,14 @@ export async function readFiles(filePaths, { cwd = process.cwd(), fsModule = DEF
     const useNativeFilesystem = fsModule === DEFAULT_FS || isNativeFsModule(fsModule);
     let candidatePaths = [];
     if (useNativeFilesystem) {
-        candidatePaths = await expandWithNativeGlob(partitioned, cwd);
+        if (partitioned.globPatterns.length === 0 &&
+            partitioned.excludePatterns.length === 0 &&
+            partitioned.literalDirectories.length === 0) {
+            candidatePaths = Array.from(new Set(partitioned.literalFiles));
+        }
+        else {
+            candidatePaths = await expandWithNativeGlob(partitioned, cwd);
+        }
     }
     else {
         if (partitioned.globPatterns.length > 0 || partitioned.excludePatterns.length > 0) {

package/dist/src/oracle/modelResolver.js

@@ -1,5 +1,6 @@
 import { MODEL_CONFIGS, PRO_MODELS } from './config.js';
 import { countTokens as countTokensGpt5Pro } from 'gpt-tokenizer/model/gpt-5-pro';
+import { pricingFromUsdPerMillion } from 'tokentally';
 const OPENROUTER_DEFAULT_BASE = 'https://openrouter.ai/api/v1';
 const OPENROUTER_MODELS_ENDPOINT = 'https://openrouter.ai/api/v1/models';
 export function isKnownModel(model) {
@@ -96,10 +97,16 @@ export async function resolveModelConfig(model, options = {}) {
                     provider: known?.provider ?? 'other',
                     inputLimit: info.context_length ?? known?.inputLimit ?? 200_000,
                     pricing: info.pricing && info.pricing.prompt != null && info.pricing.completion != null
-                        ? {
-                            inputPerToken: info.pricing.prompt / 1_000_000,
-                            outputPerToken: info.pricing.completion / 1_000_000,
-                        }
+                        ? (() => {
+                            const pricing = pricingFromUsdPerMillion({
+                                inputUsdPerMillion: info.pricing.prompt,
+                                outputUsdPerMillion: info.pricing.completion,
+                            });
+                            return {
+                                inputPerToken: pricing.inputUsdPerToken,
+                                outputPerToken: pricing.outputUsdPerToken,
+                            };
+                        })()
                         : known?.pricing ?? null,
                     supportsBackground: known?.supportsBackground ?? true,
                     supportsSearch: known?.supportsSearch ?? true,

package/dist/src/oracle/multiModelRunner.js

@@ -2,24 +2,13 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, } from '../oracle.js';
 import { sessionStore } from '../sessionStore.js';
-const OSC_PROGRESS_PREFIX = '\u001b]9;4;';
-const OSC_PROGRESS_END = '\u001b\\';
+import { findOscProgressSequences, OSC_PROGRESS_PREFIX } from 'osc-progress';
 function forwardOscProgress(chunk, shouldForward) {
     if (!shouldForward || !chunk.includes(OSC_PROGRESS_PREFIX)) {
         return;
     }
-    let searchFrom = 0;
-    while (searchFrom < chunk.length) {
-        const start = chunk.indexOf(OSC_PROGRESS_PREFIX, searchFrom);
-        if (start === -1) {
-            break;
-        }
-        const end = chunk.indexOf(OSC_PROGRESS_END, start + OSC_PROGRESS_PREFIX.length);
-        if (end === -1) {
-            break;
-        }
-        process.stdout.write(chunk.slice(start, end + OSC_PROGRESS_END.length));
-        searchFrom = end + OSC_PROGRESS_END.length;
+    for (const seq of findOscProgressSequences(chunk)) {
+        process.stdout.write(seq.raw);
     }
 }
 const defaultDeps = {

package/dist/src/oracle/oscProgress.js

@@ -1,66 +1,17 @@
 import process from 'node:process';
-const OSC = '\u001b]9;4;';
-const ST = '\u001b\\';
-function sanitizeLabel(label) {
-    const withoutEscape = label.split('\u001b').join('');
-    const withoutBellAndSt = withoutEscape.replaceAll('\u0007', '').replaceAll('\u009c', '');
-    return withoutBellAndSt.replaceAll(']', '').trim();
-}
+import { startOscProgress as startOscProgressShared, supportsOscProgress as supportsOscProgressShared, } from 'osc-progress';
 export function supportsOscProgress(env = process.env, isTty = process.stdout.isTTY) {
-    if (!isTty) {
-        return false;
-    }
-    if (env.ORACLE_NO_OSC_PROGRESS === '1') {
-        return false;
-    }
-    if (env.ORACLE_FORCE_OSC_PROGRESS === '1') {
-        return true;
-    }
-    const termProgram = (env.TERM_PROGRAM ?? '').toLowerCase();
-    if (termProgram.includes('ghostty')) {
-        return true;
-    }
-    if (termProgram.includes('wezterm')) {
-        return true;
-    }
-    if (env.WT_SESSION) {
-        return true; // Windows Terminal exposes this
-    }
-    return false;
+    return supportsOscProgressShared(env, isTty, {
+        disableEnvVar: 'ORACLE_NO_OSC_PROGRESS',
+        forceEnvVar: 'ORACLE_FORCE_OSC_PROGRESS',
+    });
 }
 export function startOscProgress(options = {}) {
-    const { label = 'Waiting for API', targetMs = 10 * 60_000, write = (text) => process.stdout.write(text), indeterminate = false, } = options;
-    if (!supportsOscProgress(options.env, options.isTty)) {
-        return () => { };
-    }
-    const cleanLabel = sanitizeLabel(label);
-    if (indeterminate) {
-        write(`${OSC}3;;${cleanLabel}${ST}`);
-        return () => {
-            write(`${OSC}0;0;${cleanLabel}${ST}`);
-        };
-    }
-    const target = Math.max(targetMs, 1_000);
-    const send = (state, percent) => {
-        const clamped = Math.max(0, Math.min(100, Math.round(percent)));
-        write(`${OSC}${state};${clamped};${cleanLabel}${ST}`);
-    };
-    const startedAt = Date.now();
-    send(1, 0); // activate progress bar
-    const timer = setInterval(() => {
-        const elapsed = Date.now() - startedAt;
-        const percent = Math.min(99, (elapsed / target) * 100);
-        send(1, percent);
-    }, 900);
-    timer.unref?.();
-    let stopped = false;
-    return () => {
-        // multiple callers may try to stop
-        if (stopped) {
-            return;
-        }
-        stopped = true;
-        clearInterval(timer);
-        send(0, 0); // clear the progress bar
-    };
+    return startOscProgressShared({
+        ...options,
+        // Preserve Oracle's previous default: progress emits to stdout.
+        write: options.write ?? ((text) => process.stdout.write(text)),
+        disableEnvVar: 'ORACLE_NO_OSC_PROGRESS',
+        forceEnvVar: 'ORACLE_FORCE_OSC_PROGRESS',
+    });
 }