@steipete/oracle 0.7.6 → 0.8.1

package/dist/src/browser/reattachHelpers.js

@@ -0,0 +1,382 @@
+import { CONVERSATION_TURN_SELECTOR } from './constants.js';
+import { delay } from './utils.js';
+import { readAssistantSnapshot } from './pageActions.js';
+export function pickTarget(targets, runtime) {
+    if (!Array.isArray(targets) || targets.length === 0) {
+        return undefined;
+    }
+    if (runtime.chromeTargetId) {
+        const byId = targets.find((t) => t.targetId === runtime.chromeTargetId);
+        if (byId)
+            return byId;
+    }
+    if (runtime.tabUrl) {
+        const byUrl = targets.find((t) => t.url?.startsWith(runtime.tabUrl)) ||
+            targets.find((t) => runtime.tabUrl.startsWith(t.url || ''));
+        if (byUrl)
+            return byUrl;
+    }
+    return targets.find((t) => t.type === 'page') ?? targets[0];
+}
+export function extractConversationIdFromUrl(url) {
+    if (!url)
+        return undefined;
+    const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
+    return match?.[1];
+}
+export function buildConversationUrl(runtime, baseUrl) {
+    if (runtime.tabUrl) {
+        if (runtime.tabUrl.includes('/c/')) {
+            return runtime.tabUrl;
+        }
+        return null;
+    }
+    const conversationId = runtime.conversationId;
+    if (!conversationId) {
+        return null;
+    }
+    try {
+        const base = new URL(baseUrl);
+        const pathRoot = base.pathname.replace(/\/$/, '');
+        const prefix = pathRoot === '/' ? '' : pathRoot;
+        return `${base.origin}${prefix}/c/${conversationId}`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function withTimeout(task, ms, label) {
+    let timeoutId;
+    const timeout = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(label)), ms);
+    });
+    return Promise.race([task, timeout]).finally(() => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    });
+}
+export async function openConversationFromSidebar(Runtime, options, attempt = 0) {
+    const response = await Runtime.evaluate({
+        expression: `(() => {
+      const conversationId = ${JSON.stringify(options.conversationId ?? null)};
+      const preferProjects = ${JSON.stringify(Boolean(options.preferProjects))};
+      const promptPreview = ${JSON.stringify(options.promptPreview ?? null)};
+      const attemptIndex = ${Math.max(0, attempt)};
+      const promptNeedleFull = promptPreview ? promptPreview.trim().toLowerCase().slice(0, 100) : '';
+      const promptNeedleShort = promptNeedleFull.replace(/\\s*\\d{4,}\\s*$/, '').trim();
+      const promptNeedles = Array.from(new Set([promptNeedleFull, promptNeedleShort].filter(Boolean)));
+      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 allElements = Array.from(
+        document.querySelectorAll(
+          'a,button,[role="link"],[role="button"],[data-href],[data-url],[data-conversation-id],[data-testid*="conversation"],[data-testid*="history"]',
+        ),
+      );
+      const getHref = (el) =>
+        el.getAttribute('href') ||
+        el.getAttribute('data-href') ||
+        el.getAttribute('data-url') ||
+        el.dataset?.href ||
+        el.dataset?.url ||
+        '';
+      const toCandidate = (el) => {
+        const clickable = el.closest('a,button,[role="link"],[role="button"]') || el;
+        const rawText = (el.textContent || clickable.textContent || '').trim();
+        return {
+          el,
+          clickable,
+          href: getHref(clickable) || getHref(el),
+          conversationId:
+            clickable.getAttribute('data-conversation-id') ||
+            el.getAttribute('data-conversation-id') ||
+            clickable.dataset?.conversationId ||
+            el.dataset?.conversationId ||
+            '',
+          testId: clickable.getAttribute('data-testid') || el.getAttribute('data-testid') || '',
+          text: rawText.replace(/\\s+/g, ' ').slice(0, 400),
+          inNav: Boolean(clickable.closest('nav,aside')),
+        };
+      };
+      const candidates = allElements.map(toCandidate);
+      const mainCandidates = candidates.filter((item) => !item.inNav);
+      const navCandidates = candidates.filter((item) => item.inNav);
+      const visible = (item) => {
+        const rect = item.clickable.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+      const pick = (items) => (items.find(visible) || items[0] || null);
+      const pickWithAttempt = (items) => {
+        if (!items.length) return null;
+        const visibleItems = items.filter(visible);
+        const pool = visibleItems.length > 0 ? visibleItems : items;
+        const index = Math.min(attemptIndex, pool.length - 1);
+        return pool[index] ?? null;
+      };
+      let target = null;
+      if (conversationId) {
+        const byId = (item) =>
+          (item.href && item.href.includes('/c/' + conversationId)) ||
+          (item.conversationId && item.conversationId === conversationId);
+        target = pick(mainCandidates.filter(byId)) || pick(navCandidates.filter(byId));
+      }
+      if (!target && promptNeedles.length > 0) {
+        const byPrompt = (item) => promptNeedles.some((needle) => item.text && item.text.toLowerCase().includes(needle));
+        const sortBySpecificity = (items) =>
+          items
+            .filter(byPrompt)
+            .sort((a, b) => (a.text?.length ?? 0) - (b.text?.length ?? 0));
+        target = pickWithAttempt(sortBySpecificity(mainCandidates)) || pickWithAttempt(sortBySpecificity(navCandidates));
+      }
+      if (!target) {
+        const byHref = (item) => item.href && item.href.includes('/c/');
+        target = pickWithAttempt(mainCandidates.filter(byHref)) || pickWithAttempt(navCandidates.filter(byHref));
+      }
+      if (!target) {
+        const byTestId = (item) => /conversation|history/i.test(item.testId || '');
+        target = pickWithAttempt(mainCandidates.filter(byTestId)) || pickWithAttempt(navCandidates.filter(byTestId));
+      }
+      if (target) {
+        target.clickable.scrollIntoView({ block: 'center' });
+        target.clickable.dispatchEvent(
+          new MouseEvent('click', { bubbles: true, cancelable: true, view: window }),
+        );
+        // Fallback: some project-sidebar items don't navigate on click, force the URL.
+        if (target.href && target.href.includes('/c/')) {
+          const targetUrl = target.href.startsWith('http')
+            ? target.href
+            : new URL(target.href, location.origin).toString();
+          if (targetUrl && targetUrl !== location.href) {
+            location.href = targetUrl;
+          }
+        }
+        return {
+          ok: true,
+          href: target.href || '',
+          count: candidates.length,
+          scope: target.inNav ? 'nav' : 'main',
+        };
+      }
+      return { ok: false, count: candidates.length };
+    })()`,
+        returnByValue: true,
+    });
+    return Boolean(response.result?.value?.ok);
+}
+export async function openConversationFromSidebarWithRetry(Runtime, options, timeoutMs) {
+    const start = Date.now();
+    let attempt = 0;
+    while (Date.now() - start < timeoutMs) {
+        // Retry because project list can hydrate after initial navigation.
+        const opened = await openConversationFromSidebar(Runtime, options, attempt);
+        if (opened) {
+            if (options.promptPreview) {
+                const matched = await waitForPromptPreview(Runtime, options.promptPreview, 10_000);
+                if (matched) {
+                    return true;
+                }
+            }
+            else {
+                return true;
+            }
+        }
+        attempt += 1;
+        await delay(attempt < 5 ? 250 : 500);
+    }
+    return false;
+}
+export async function waitForPromptPreview(Runtime, promptPreview, timeoutMs) {
+    const needleFull = promptPreview.trim().toLowerCase().slice(0, 120);
+    const needleShort = needleFull.replace(/\\s*\\d{4,}\\s*$/, '').trim();
+    const needles = Array.from(new Set([needleFull, needleShort].filter(Boolean)));
+    if (needles.length === 0)
+        return false;
+    const selectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const expression = `(() => {
+    const needles = ${JSON.stringify(needles)};
+    const root =
+      document.querySelector('section[data-testid="screen-threadFlyOut"]') ||
+      document.querySelector('[data-testid="chat-thread"]') ||
+      document.querySelector('main') ||
+      document.querySelector('[role="main"]');
+    if (!root) return false;
+    const userTurns = Array.from(root.querySelectorAll('[data-message-author-role="user"], [data-turn="user"]'));
+    const collectText = (nodes) =>
+      nodes
+        .map((node) => (node.innerText || node.textContent || ''))
+        .join(' ')
+        .toLowerCase();
+    let text = collectText(userTurns);
+    let hasTurns = userTurns.length > 0;
+    if (!text) {
+      const turns = Array.from(root.querySelectorAll(${selectorLiteral}));
+      hasTurns = hasTurns || turns.length > 0;
+      text = collectText(turns);
+    }
+    if (!text) {
+      text = (root.innerText || root.textContent || '').toLowerCase();
+    }
+    return needles.some((needle) => text.includes(needle));
+  })()`;
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+            if (result?.value === true) {
+                return true;
+            }
+        }
+        catch {
+            // ignore
+        }
+        await delay(300);
+    }
+    return false;
+}
+export 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);
+    }
+}
+export async function readConversationTurnIndex(Runtime, logger) {
+    const selectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    try {
+        const { result } = await Runtime.evaluate({
+            expression: `document.querySelectorAll(${selectorLiteral}).length`,
+            returnByValue: true,
+        });
+        const raw = typeof result?.value === 'number' ? result.value : Number(result?.value);
+        if (!Number.isFinite(raw)) {
+            throw new Error('Turn count not numeric');
+        }
+        return Math.max(0, Math.floor(raw) - 1);
+    }
+    catch (error) {
+        if (logger?.verbose) {
+            logger(`Failed to read conversation turn index: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return null;
+    }
+}
+function normalizeForComparison(text) {
+    return String(text || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+}
+export function buildPromptEchoMatcher(promptPreview) {
+    const normalizedPrompt = normalizeForComparison(promptPreview ?? '');
+    if (!normalizedPrompt) {
+        return null;
+    }
+    const promptPrefix = normalizedPrompt.length >= 80 ? normalizedPrompt.slice(0, Math.min(200, normalizedPrompt.length)) : '';
+    const minFragment = Math.min(40, normalizedPrompt.length);
+    return {
+        isEcho: (text) => {
+            const normalized = normalizeForComparison(text);
+            if (!normalized)
+                return false;
+            if (normalized === normalizedPrompt)
+                return true;
+            if (promptPrefix.length > 0 && normalized.startsWith(promptPrefix))
+                return true;
+            if (normalized.length >= minFragment && normalizedPrompt.startsWith(normalized)) {
+                return true;
+            }
+            if (normalized.includes('…') || normalized.includes('...')) {
+                const marker = normalized.includes('…') ? '…' : '...';
+                const [prefixRaw, suffixRaw] = normalized.split(marker);
+                const prefix = prefixRaw?.trim() ?? '';
+                const suffix = suffixRaw?.trim() ?? '';
+                if (!prefix && !suffix)
+                    return false;
+                if (prefix && !normalizedPrompt.includes(prefix))
+                    return false;
+                if (suffix && !normalizedPrompt.includes(suffix))
+                    return false;
+                const fragmentLength = prefix.length + suffix.length;
+                return fragmentLength >= minFragment;
+            }
+            return false;
+        },
+    };
+}
+export async function recoverPromptEcho(Runtime, answer, matcher, logger, minTurnIndex, timeoutMs) {
+    if (!matcher || !matcher.isEcho(answer.text)) {
+        return answer;
+    }
+    logger('Detected prompt echo while reattaching; waiting for assistant response...');
+    const deadline = Date.now() + Math.min(timeoutMs, 15_000);
+    let bestText = null;
+    let stableCount = 0;
+    while (Date.now() < deadline) {
+        const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex ?? undefined).catch(() => null);
+        const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+        if (!text || matcher.isEcho(text)) {
+            await delay(300);
+            continue;
+        }
+        if (!bestText || text.length > bestText.length) {
+            bestText = text;
+            stableCount = 0;
+        }
+        else if (text === bestText) {
+            stableCount += 1;
+        }
+        if (stableCount >= 2) {
+            break;
+        }
+        await delay(300);
+    }
+    if (bestText) {
+        logger('Recovered assistant response after prompt echo during reattach');
+        return { ...answer, text: bestText };
+    }
+    return answer;
+}
+export function alignPromptEchoPair(answerText, answerMarkdown, matcher, logger, messages) {
+    if (!matcher) {
+        return { answerText, answerMarkdown, textEcho: false, markdownEcho: false, isEcho: false };
+    }
+    let textEcho = matcher.isEcho(answerText);
+    let markdownEcho = matcher.isEcho(answerMarkdown);
+    if (textEcho && !markdownEcho && answerMarkdown) {
+        if (logger && messages?.text) {
+            logger(messages.text);
+        }
+        answerText = answerMarkdown;
+        textEcho = false;
+    }
+    if (markdownEcho && !textEcho && answerText) {
+        if (logger && messages?.markdown) {
+            logger(messages.markdown);
+        }
+        answerMarkdown = answerText;
+        markdownEcho = false;
+    }
+    return {
+        answerText,
+        answerMarkdown,
+        textEcho,
+        markdownEcho,
+        isEcho: textEcho || markdownEcho,
+    };
+}
+export function alignPromptEchoMarkdown(answerText, answerMarkdown, matcher, logger) {
+    const aligned = alignPromptEchoPair(answerText, answerMarkdown, matcher, logger, {
+        text: 'Aligned prompt-echo text to copied markdown during reattach',
+        markdown: 'Aligned prompt-echo markdown to response text during reattach',
+    });
+    return { answerText: aligned.answerText, answerMarkdown: aligned.answerMarkdown };
+}

package/dist/src/browserMode.js

@@ -1 +1 @@
-export { runBrowserMode, CHATGPT_URL, DEFAULT_MODEL_TARGET, parseDuration, normalizeChatgptUrl, isTemporaryChatUrl, } from './browser/index.js';
+export { runBrowserMode, CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET, parseDuration, normalizeChatgptUrl, isTemporaryChatUrl, } from './browser/index.js';

package/dist/src/cli/browserConfig.js

@@ -1,9 +1,10 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { CHATGPT_URL, DEFAULT_MODEL_TARGET, isTemporaryChatUrl, normalizeChatgptUrl, parseDuration } from '../browserMode.js';
+import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET, isTemporaryChatUrl, normalizeChatgptUrl, parseDuration } from '../browserMode.js';
+import { normalizeBrowserModelStrategy } from '../browser/modelStrategy.js';
 import { getOracleHomeDir } from '../oracleHome.js';
 const DEFAULT_BROWSER_TIMEOUT_MS = 1_200_000;
-const DEFAULT_BROWSER_INPUT_TIMEOUT_MS = 30_000;
+const DEFAULT_BROWSER_INPUT_TIMEOUT_MS = 60_000;
 const DEFAULT_CHROME_PROFILE = 'Default';
 // 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.
@@ -44,14 +45,18 @@ export async function buildBrowserConfig(options) {
     const baseModel = options.model.toLowerCase();
     const isChatGptModel = baseModel.startsWith('gpt-') && !baseModel.includes('codex');
     const shouldUseOverride = !isChatGptModel && normalizedOverride.length > 0 && normalizedOverride !== baseModel;
+    const modelStrategy = normalizeBrowserModelStrategy(options.browserModelStrategy) ?? DEFAULT_MODEL_STRATEGY;
     const cookieNames = parseCookieNames(options.browserCookieNames ?? process.env.ORACLE_BROWSER_COOKIE_NAMES);
-    const inline = await resolveInlineCookies({
+    let inline = await resolveInlineCookies({
         inlineArg: options.browserInlineCookies,
         inlineFileArg: options.browserInlineCookiesFile,
         envPayload: process.env.ORACLE_BROWSER_COOKIES_JSON,
         envFile: process.env.ORACLE_BROWSER_COOKIES_FILE,
         cwd: process.cwd(),
     });
+    if (inline?.source?.startsWith('home:') && options.browserNoCookieSync !== true) {
+        inline = undefined;
+    }
     let remoteChrome;
     if (options.remoteChrome) {
         remoteChrome = parseRemoteChromeTarget(options.remoteChrome);
@@ -63,7 +68,7 @@ export async function buildBrowserConfig(options) {
         : shouldUseOverride
             ? desiredModelOverride
             : mapModelToBrowserLabel(options.model);
-    if (url && isTemporaryChatUrl(url) && /\bpro\b/i.test(desiredModel ?? '')) {
+    if (modelStrategy === 'select' && url && isTemporaryChatUrl(url) && /\bpro\b/i.test(desiredModel ?? '')) {
         throw new Error('Temporary Chat mode does not expose Pro models in the ChatGPT model picker. ' +
             'Remove "temporary-chat=true" from --chatgpt-url (or omit --chatgpt-url), or use a non-Pro model (e.g. --model gpt-5.2).');
     }
@@ -83,9 +88,11 @@ export async function buildBrowserConfig(options) {
         inlineCookiesSource: inline?.source ?? null,
         headless: undefined, // disable headless; Cloudflare blocks it
         keepBrowser: options.browserKeepBrowser ? true : undefined,
-        manualLogin: options.browserManualLogin ? true : undefined,
+        manualLogin: options.browserManualLogin === undefined ? undefined : options.browserManualLogin,
+        manualLoginProfileDir: options.browserManualLoginProfileDir ?? undefined,
         hideWindow: options.browserHideWindow ? true : undefined,
         desiredModel,
+        modelStrategy,
         debug: options.verbose ? true : undefined,
         // Allow cookie failures by default so runs can continue without Chrome/Keychain secrets.
         allowCookieErrors: options.browserAllowCookieErrors ?? true,

package/dist/src/cli/browserDefaults.js

@@ -42,4 +42,16 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     if (isUnset('browserKeepBrowser') && browser.keepBrowser !== undefined) {
         options.browserKeepBrowser = browser.keepBrowser;
     }
+    if (isUnset('browserModelStrategy') && browser.modelStrategy !== undefined) {
+        options.browserModelStrategy = browser.modelStrategy;
+    }
+    if (isUnset('browserThinkingTime') && browser.thinkingTime !== undefined) {
+        options.browserThinkingTime = browser.thinkingTime;
+    }
+    if (isUnset('browserManualLogin') && browser.manualLogin !== undefined) {
+        options.browserManualLogin = browser.manualLogin;
+    }
+    if (isUnset('browserManualLoginProfileDir') && browser.manualLoginProfileDir !== undefined) {
+        options.browserManualLoginProfileDir = browser.manualLoginProfileDir;
+    }
 }

package/dist/src/cli/sessionDisplay.js

@@ -61,6 +61,13 @@ export async function attachSession(sessionId, options) {
         process.exitCode = 1;
         return;
     }
+    if (metadata.mode === 'browser' && metadata.status === 'running' && !metadata.browser?.runtime) {
+        await wait(250);
+        const refreshed = await sessionStore.readSession(sessionId);
+        if (refreshed) {
+            metadata = refreshed;
+        }
+    }
     const normalizedModelFilter = options?.model?.trim().toLowerCase();
     if (normalizedModelFilter) {
         const availableModels = metadata.models?.map((model) => model.model.toLowerCase()) ??

package/dist/src/gemini-web/executor.js

@@ -1,5 +1,27 @@
 import path from 'node:path';
+import { getCookies } from '@steipete/sweet-cookie';
 import { runGeminiWebWithFallback, saveFirstGeminiImageFromOutput } from './client.js';
+const GEMINI_COOKIE_NAMES = [
+    '__Secure-1PSID',
+    '__Secure-1PSIDTS',
+    '__Secure-1PSIDCC',
+    '__Secure-1PAPISID',
+    'NID',
+    'AEC',
+    'SOCS',
+    '__Secure-BUCKET',
+    '__Secure-ENID',
+    'SID',
+    'HSID',
+    'SSID',
+    'APISID',
+    'SAPISID',
+    '__Secure-3PSID',
+    '__Secure-3PSIDTS',
+    '__Secure-3PAPISID',
+    'SIDCC',
+];
+const GEMINI_REQUIRED_COOKIES = ['__Secure-1PSID', '__Secure-1PSIDTS'];
 function estimateTokenCount(text) {
     return Math.ceil(text.length / 4);
 }
@@ -30,59 +52,84 @@ function resolveGeminiWebModel(desiredModel, log) {
             return 'gemini-3-pro';
     }
 }
+function resolveCookieDomain(cookie) {
+    const rawDomain = cookie.domain?.trim();
+    if (rawDomain) {
+        return rawDomain.startsWith('.') ? rawDomain.slice(1) : rawDomain;
+    }
+    const rawUrl = cookie.url?.trim();
+    if (rawUrl) {
+        try {
+            return new URL(rawUrl).hostname;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function pickCookieValue(cookies, name) {
+    const matches = cookies.filter((cookie) => cookie.name === name && typeof cookie.value === 'string');
+    if (matches.length === 0)
+        return undefined;
+    const preferredDomain = matches.find((cookie) => {
+        const domain = resolveCookieDomain(cookie);
+        return domain === 'google.com' && (cookie.path ?? '/') === '/';
+    });
+    const googleDomain = matches.find((cookie) => (resolveCookieDomain(cookie) ?? '').endsWith('google.com'));
+    return (preferredDomain ?? googleDomain ?? matches[0])?.value;
+}
+function buildGeminiCookieMap(cookies) {
+    const cookieMap = {};
+    for (const name of GEMINI_COOKIE_NAMES) {
+        const value = pickCookieValue(cookies, name);
+        if (value)
+            cookieMap[name] = value;
+    }
+    return cookieMap;
+}
+function hasRequiredGeminiCookies(cookieMap) {
+    return GEMINI_REQUIRED_COOKIES.every((name) => Boolean(cookieMap[name]));
+}
+async function loadGeminiCookiesFromInline(browserConfig, log) {
+    const inline = browserConfig?.inlineCookies;
+    if (!inline || inline.length === 0)
+        return {};
+    const cookieMap = buildGeminiCookieMap(inline.filter((cookie) => Boolean(cookie?.name && typeof cookie.value === 'string')));
+    if (Object.keys(cookieMap).length > 0) {
+        const source = browserConfig?.inlineCookiesSource ?? 'inline';
+        log?.(`[gemini-web] Loaded Gemini cookies from inline payload (${source}): ${Object.keys(cookieMap).length} cookie(s).`);
+    }
+    else {
+        log?.('[gemini-web] Inline cookie payload provided but no Gemini cookies matched.');
+    }
+    return cookieMap;
+}
 async function loadGeminiCookiesFromChrome(browserConfig, log) {
     try {
-        const mod = (await import('chrome-cookies-secure'));
-        const chromeCookies = mod.default ??
-            mod;
-        const profile = typeof browserConfig?.chromeProfile === 'string' &&
-            browserConfig.chromeProfile.trim().length > 0
-            ? browserConfig.chromeProfile.trim()
+        // Learned: Gemini web relies on Google auth cookies in the *browser* profile, not API keys.
+        const profileCandidate = browserConfig?.chromeCookiePath ?? browserConfig?.chromeProfile ?? undefined;
+        const profile = typeof profileCandidate === 'string' && profileCandidate.trim().length > 0
+            ? profileCandidate.trim()
             : undefined;
         const sources = [
             'https://gemini.google.com',
             'https://accounts.google.com',
             'https://www.google.com',
         ];
-        const wantNames = [
-            '__Secure-1PSID',
-            '__Secure-1PSIDTS',
-            '__Secure-1PSIDCC',
-            '__Secure-1PAPISID',
-            'NID',
-            'AEC',
-            'SOCS',
-            '__Secure-BUCKET',
-            '__Secure-ENID',
-            'SID',
-            'HSID',
-            'SSID',
-            'APISID',
-            'SAPISID',
-            '__Secure-3PSID',
-            '__Secure-3PSIDTS',
-            '__Secure-3PAPISID',
-            'SIDCC',
-        ];
-        const cookieMap = {};
-        for (const url of sources) {
-            const cookies = (await chromeCookies.getCookiesPromised(url, 'puppeteer', profile));
-            for (const name of wantNames) {
-                if (cookieMap[name])
-                    continue;
-                const matches = cookies.filter((cookie) => cookie.name === name);
-                if (matches.length === 0)
-                    continue;
-                const preferredDomain = matches.find((cookie) => cookie.domain === '.google.com' && (cookie.path ?? '/') === '/');
-                const googleDomain = matches.find((cookie) => (cookie.domain ?? '').endsWith('google.com'));
-                const value = (preferredDomain ?? googleDomain ?? matches[0])?.value;
-                if (value)
-                    cookieMap[name] = value;
-            }
-        }
-        if (!cookieMap['__Secure-1PSID'] || !cookieMap['__Secure-1PSIDTS']) {
-            return {};
+        const { cookies, warnings } = await getCookies({
+            url: sources[0],
+            origins: sources,
+            names: [...GEMINI_COOKIE_NAMES],
+            browsers: ['chrome'],
+            mode: 'merge',
+            chromeProfile: profile,
+            timeoutMs: 5_000,
+        });
+        if (warnings.length && log?.verbose) {
+            log(`[gemini-web] Cookie warnings:\n- ${warnings.join('\n- ')}`);
         }
+        const cookieMap = buildGeminiCookieMap(cookies);
         log?.(`[gemini-web] Loaded Gemini cookies from Chrome (node): ${Object.keys(cookieMap).length} cookie(s).`);
         return cookieMap;
     }
@@ -91,13 +138,27 @@ async function loadGeminiCookiesFromChrome(browserConfig, log) {
         return {};
     }
 }
+async function loadGeminiCookies(browserConfig, log) {
+    const inlineMap = await loadGeminiCookiesFromInline(browserConfig, log);
+    const hasInlineRequired = hasRequiredGeminiCookies(inlineMap);
+    if (hasInlineRequired && browserConfig?.cookieSync === false) {
+        return inlineMap;
+    }
+    if (browserConfig?.cookieSync === false && !hasInlineRequired) {
+        log?.('[gemini-web] Cookie sync disabled and inline cookies missing Gemini auth tokens.');
+        return inlineMap;
+    }
+    const chromeMap = await loadGeminiCookiesFromChrome(browserConfig, log);
+    const merged = { ...chromeMap, ...inlineMap };
+    return merged;
+}
 export function createGeminiWebExecutor(geminiOptions) {
     return async (runOptions) => {
         const startTime = Date.now();
         const log = runOptions.log;
         log?.('[gemini-web] Starting Gemini web executor (TypeScript)');
-        const cookieMap = await loadGeminiCookiesFromChrome(runOptions.config, log);
-        if (!cookieMap['__Secure-1PSID'] || !cookieMap['__Secure-1PSIDTS']) {
+        const cookieMap = await loadGeminiCookies(runOptions.config, log);
+        if (!hasRequiredGeminiCookies(cookieMap)) {
             throw new Error('Gemini browser mode requires Chrome cookies for google.com (missing __Secure-1PSID/__Secure-1PSIDTS).');
         }
         const configTimeout = typeof runOptions.config?.timeoutMs === 'number' && Number.isFinite(runOptions.config.timeoutMs)

package/dist/src/oracle/oscProgress.js

@@ -1,12 +1,19 @@
 import process from 'node:process';
 import { startOscProgress as startOscProgressShared, supportsOscProgress as supportsOscProgressShared, } from 'osc-progress';
 export function supportsOscProgress(env = process.env, isTty = process.stdout.isTTY) {
+    if (env.CODEX_MANAGED_BY_NPM === '1' && env.ORACLE_FORCE_OSC_PROGRESS !== '1') {
+        return false;
+    }
     return supportsOscProgressShared(env, isTty, {
         disableEnvVar: 'ORACLE_NO_OSC_PROGRESS',
         forceEnvVar: 'ORACLE_FORCE_OSC_PROGRESS',
     });
 }
 export function startOscProgress(options = {}) {
+    const env = options.env ?? process.env;
+    if (env.CODEX_MANAGED_BY_NPM === '1' && env.ORACLE_FORCE_OSC_PROGRESS !== '1') {
+        return () => { };
+    }
     return startOscProgressShared({
         ...options,
         // Preserve Oracle's previous default: progress emits to stdout.