@steipete/oracle 0.17.2 → 0.18.0

package/dist/src/browser/actions/thinkingTime.js

@@ -1,6 +1,35 @@
 import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR, MODEL_BUTTON_SELECTOR, } from "../constants.js";
 import { logDomFailure } from "../domDebug.js";
 import { buildClickDispatcher } from "./domEvents.js";
+import { BrowserAutomationError } from "../../oracle/errors.js";
+export class ThinkingTierUnavailableError extends BrowserAutomationError {
+    requestedLevel;
+    requestedLabel;
+    optionLabel;
+    notice;
+    confirmedTarget;
+    constructor(requestedLevel, requestedLabel, optionLabel, notice, confirmedTarget) {
+        const message = `Thinking time: ${optionLabel ?? requestedLabel} is unavailable on this account (${notice ?? "no reason given"}); refusing to submit without confirmed ${confirmedTarget}.`;
+        super(message, {
+            stage: "thinking-tier-unavailable",
+            requestedLevel,
+            requestedLabel,
+            optionLabel,
+            notice,
+            confirmedTarget,
+        });
+        this.name = "ThinkingTierUnavailableError";
+        this.requestedLevel = requestedLevel;
+        this.requestedLabel = requestedLabel;
+        this.optionLabel = optionLabel;
+        this.notice = notice;
+        this.confirmedTarget = confirmedTarget;
+    }
+}
+function confirmedThinkingTarget(level, capitalizedLevel, targetModelKind, observedModelKind) {
+    const strictModelKind = targetModelKind ?? observedModelKind;
+    return level === "pro" ? "Pro" : strictModelKind === "pro" ? "Pro Extended" : capitalizedLevel;
+}
 const BROWSER_THINKING_LOG_PREFIX = "[browser] Thinking time:";
 function formatBrowserThinkingLog(message) {
     return `${BROWSER_THINKING_LOG_PREFIX} ${message.replace(/^Thinking time:\s*/, "")}`;
@@ -43,6 +72,18 @@ export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
         case "switched":
             logger(formatBrowserThinkingLog(result.label ?? capitalizedLevel));
             return;
+        case "option-disabled": {
+            await logDomFailure(Runtime, logger, "thinking-option-disabled");
+            logPickerDiagnostic(result, logger);
+            if (strictProEffort) {
+                throw new ThinkingTierUnavailableError(level, capitalizedLevel, result.label ?? null, result.notice ?? null, confirmedThinkingTarget(level, capitalizedLevel, targetModelKind, observedModelKind));
+            }
+            // A non-strict caller goes on to submit, so this log must not borrow the
+            // strict error's "refusing to submit" wording: the request really is sent,
+            // at whatever effort ChatGPT already had selected.
+            logger(formatBrowserThinkingLog(`${result.label ?? capitalizedLevel} is unavailable on this account (${result.notice ?? "no reason given"}); keeping the effort already selected in ChatGPT.`));
+            return;
+        }
         case "chip-not-found":
         case "menu-not-found":
         case "option-not-found":
@@ -97,6 +138,9 @@ export async function ensureThinkingTimeIfAvailable(Runtime, level, logger, desi
             case "switched":
                 logger(formatBrowserThinkingLog(result.label ?? capitalizedLevel));
                 return true;
+            case "option-disabled":
+                logger(formatBrowserThinkingLog(`${result.label ?? capitalizedLevel} is unavailable on this account (${result.notice ?? "no reason given"}); keeping the effort already selected in ChatGPT.`));
+                return false;
             case "chip-not-found":
             case "menu-not-found":
             case "option-not-found":
@@ -147,12 +191,12 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const TARGET_MODEL_KIND = ${targetModelKindLiteral};
     const TARGET_IS_GPT56_MODEL = ${targetIsGpt56ModelLiteral};
 
-    // Multilingual matchers: English level token + observed German/Chinese variants.
+    // Multilingual matchers: English level token + observed German/Japanese/Chinese variants.
     const LEVEL_TOKENS = {
-      light: ['light', 'instant', 'sofort', 'leicht', '轻', '极速'],
-      standard: ['standard', 'medium', 'mittel', '标准', '中'],
-      extended: ['extended', 'high', 'hoch', 'erweitert', '扩展', '深度', '加强', '高'],
-      'extra-high': ['extra high', 'sehr hoch', '极高'],
+      light: ['light', 'instant', 'sofort', 'leicht', '最速', '轻', '极速'],
+      standard: ['standard', 'medium', 'mittel', '中程度', '标准', '中'],
+      extended: ['extended', 'high', 'hoch', 'erweitert', '高い', '扩展', '深度', '加强', '高'],
+      'extra-high': ['extra high', 'sehr hoch', '非常に高い', '极高'],
       heavy: ['heavy', 'schwer', '重度', '加重'],
     };
     // Pro is a tier you can request, but it is also a MODEL name, so it must never
@@ -171,7 +215,8 @@ function buildThinkingTimeExpression(level, desiredModel) {
     const INTELLIGENCE_WAIT_MS = 2500;
 
     const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-    // Keep CJK characters so we can match Chinese labels against LEVEL_TOKENS.
+    // Keep CJK characters, including Japanese kana, so localized labels survive
+    // normalization before being matched against LEVEL_TOKENS and picker controls.
     const normalize = (value) => (value || '')
       // Compose first so NFD umlauts fold too, then map them onto ASCII before
       // the strip below would drop them (and split the token in half).
@@ -181,7 +226,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
       .replace(/ö/g, 'o')
       .replace(/ü/g, 'u')
       .replace(/ß/g, 'ss')
-      .replace(/[^a-z0-9\\u4e00-\\u9fa5]+/g, ' ')
+      .replace(/[^a-z0-9\\u3040-\\u30ff\\u4e00-\\u9fff]+/g, ' ')
       .replace(/\\s+/g, ' ')
       .trim();
     const hasToken = (text, token) => normalize(text).split(' ').includes(token);
@@ -210,6 +255,9 @@ function buildThinkingTimeExpression(level, desiredModel) {
         if (token === 'extra high') return hasPhrase(t, 'extra high');
         if (token === 'hoch') return hasPhrase(t, 'hoch') && !hasPhrase(t, 'sehr hoch');
         if (token === 'sehr hoch') return hasPhrase(t, 'sehr hoch');
+        if (token === '高い' || token === '非常に高い') {
+          return t === token || hasToken(t, token);
+        }
         if (token === '极速') {
           const suffix = t.slice(token.length);
           return t === token || hasToken(t, token) || /^[0-9]/.test(suffix);
@@ -288,6 +336,21 @@ function buildThinkingTimeExpression(level, desiredModel) {
         .replace(/\\s+/g, ' ')
         .trim()
         .slice(0, maxLength);
+    const isOptionDisabled = (node) => {
+      if (!node || typeof node.getAttribute !== 'function') return false;
+      // data-disabled is Radix's valueless-presence convention, but an explicit
+      // "false" must not read as disabled: that would refuse a perfectly usable
+      // tier and report it as unavailable.
+      const dataDisabled = node.getAttribute('data-disabled');
+      const dataDisabledOn = dataDisabled !== null && String(dataDisabled).toLowerCase() !== 'false';
+      return (
+        node.getAttribute('aria-disabled') === 'true' ||
+        dataDisabledOn ||
+        (node.getAttribute('data-state') || '').toLowerCase() === 'disabled' ||
+        Boolean(node.disabled) ||
+        node.getAttribute('disabled') !== null
+      );
+    };
     const describeNode = (el) => {
       if (!el || typeof el.getAttribute !== 'function') return null;
       let rect = null;
@@ -310,7 +373,10 @@ function buildThinkingTimeExpression(level, desiredModel) {
         ariaChecked: el.getAttribute('aria-checked'),
         ariaSelected: el.getAttribute('aria-selected'),
         ariaHaspopup: el.getAttribute('aria-haspopup'),
+        ariaDisabled: el.getAttribute('aria-disabled'),
+        dataDisabled: el.getAttribute('data-disabled'),
         dataState: el.getAttribute('data-state'),
+        disabled: isOptionDisabled(el),
         text: redactDiagnosticText(el.textContent, 80),
         rect,
       };
@@ -586,6 +652,77 @@ function buildThinkingTimeExpression(level, desiredModel) {
       }
       return matchesLevel(normalizedLabel);
     };
+    const nonEmptyNotice = (value) => {
+      const text = redactDiagnosticText(value, 160);
+      return text || null;
+    };
+    // The notice must be ROW-OWNED, and preferably this hover's own.
+    //
+    // NOTE: no backticks in this comment — it lives inside the injected template
+    // literal, where a backtick would terminate the string.
+    //
+    // A document-wide role=tooltip scan is what this must never become: novelty is
+    // not causality, and an unrelated control with an armed open-delay can mount its
+    // tooltip inside this hover's window. Every pass below is anchored on the row.
+    //
+    // Preference order, strongest provenance first:
+    //   1. an id this hover ADDED whose target is role=tooltip — Radix keeps an
+    //      application-supplied description and APPENDS its tooltip id when opening,
+    //      so the delta is what separates the real notice from a permanent blurb;
+    //   2. any other id this hover added;
+    //   3. an already-associated role=tooltip target, for a tooltip that was open
+    //      before the probe arrived;
+    //   4. the row's static title, only once the poll has expired.
+    //
+    // Passes 3 and 4 are row-owned but NOT causal: a page that permanently points a
+    // disabled row at generic role=tooltip help, or gives it a generic title, will
+    // have that text reported. That is accepted deliberately — the value is an opaque
+    // notice for a human or a caller to interpret, not a parsed reset time — and the
+    // verified live target has neither at rest.
+    const describedIds = (option) =>
+      (option?.getAttribute?.('aria-describedby') || '').split(/\\s+/).filter(Boolean);
+    const isTooltipNode = (node) => node?.getAttribute?.('role') === 'tooltip';
+    const readDisabledNotice = (option, priorIds, allowTitle) => {
+      const ids = describedIds(option);
+      const prior = priorIds instanceof Set ? priorIds : new Set();
+      const fresh = ids.filter((id) => !prior.has(id));
+      for (const pass of [
+        fresh.filter((id) => isTooltipNode(document.getElementById?.(id))),
+        fresh,
+        ids.filter((id) => isTooltipNode(document.getElementById?.(id))),
+      ]) {
+        for (const id of pass) {
+          const notice = nonEmptyNotice(document.getElementById?.(id)?.textContent);
+          if (notice) return notice;
+        }
+      }
+      if (!allowTitle) return null;
+      return nonEmptyNotice(option?.getAttribute?.('title'));
+    };
+    const waitForDisabledNotice = async (option, priorIds) => {
+      const deadline = performance.now() + 400;
+      while (performance.now() < deadline) {
+        const notice = readDisabledNotice(option, priorIds, false);
+        if (notice) return notice;
+        await sleep(50);
+      }
+      // Only now may a static title speak: the association had its full window.
+      return readDisabledNotice(option, priorIds, true);
+    };
+    // Opening a tooltip stacks another Radix dismissable layer over the menu, and
+    // the topmost layer eats the Escape. One blind Escape therefore leaves the
+    // effort menu open, which matters for the non-strict caller that goes on to
+    // submit. Dismiss, let the layer unmount, and only Escape again while a menu is
+    // still there — never two unconditional Escapes, which could close an unrelated
+    // outer surface.
+    const closeMenusAfterTooltip = async () => {
+      closeOpenMenus();
+      for (let attempt = 0; attempt < 3; attempt += 1) {
+        await sleep(50);
+        if (!Array.from(document.querySelectorAll(MENU_CONTAINER_SELECTOR)).some(isVisible)) return;
+        closeOpenMenus();
+      }
+    };
     const selectAndVerify = async (trigger, findOption, modelKindOverride = null) => {
       const triggerModelKind =
         modelKindOverride ||
@@ -611,6 +748,22 @@ function buildThinkingTimeExpression(level, desiredModel) {
       }
       if (!option) return failure('option-not-found', { modelKind: triggerModelKind });
       const label = option.textContent?.trim?.() || null;
+      if (isOptionDisabled(option)) {
+        // Captured BEFORE the hover: the ids already here describe the row for other
+        // reasons and cannot be this hover's reason.
+        const priorIds = new Set(describedIds(option));
+        dispatchHoverSequence(option);
+        const notice = await waitForDisabledNotice(option, priorIds);
+        const result = failure('option-disabled', {
+          // The label is page text that reaches logs and diagnostics, so it is
+          // redacted like every other reported string.
+          label: redactDiagnosticText(option.textContent, 80) || null,
+          notice,
+          modelKind: triggerModelKind,
+        });
+        await closeMenusAfterTooltip();
+        return result;
+      }
       if (optionIsSelected(option)) {
         closeOpenMenus();
         return { status: 'already-selected', label };
@@ -688,9 +841,12 @@ function buildThinkingTimeExpression(level, desiredModel) {
     // Row labels in this menu concatenate without separators ("EffortHigh"), so
     // token matching cannot be used here — substring is deliberate, as in
     // countEffortLevels above.
-    const ADVANCED_WORDS = ['advanced', 'erweitert', '高级', 'avanzado', 'avancado', 'avance'];
+    const ADVANCED_WORDS = [
+      'advanced', 'erweitert', '高级', '詳細設定', '詳細表示',
+      'avanzado', 'avancado', 'avance',
+    ];
     const EFFORT_WORDS = [
-      'effort', 'aufwand', '强度', '努力',
+      'effort', 'aufwand', '强度', '努力', '推論レベル',
       'esfuerzo', 'esforco', 'sforzo', 'inspanning', 'wysilek',
     ];
     const containsAny = (label, words) => words.some((word) => label.includes(word));

package/dist/src/browser/chromeCookies.js

@@ -0,0 +1,312 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import chromeCookies from 'chrome-cookies-secure';
+import { COOKIE_URLS } from './constants.js';
+import { ensureCookiesDirForFallback } from './windowsCookies.js';
+const COOKIE_READ_TIMEOUT_MS = readDuration('ORACLE_COOKIE_LOAD_TIMEOUT_MS', 5_000);
+const KEYCHAIN_PROBE_TIMEOUT_MS = readDuration('ORACLE_KEYCHAIN_PROBE_TIMEOUT_MS', 3_000);
+const MAC_KEYCHAIN_LABELS = loadKeychainLabels();
+export async function loadChromeCookies({ targetUrl, profile, explicitCookiePath, filterNames, }) {
+    if (process.platform === 'win32') {
+        throw new Error('Cookie sync is disabled on Windows; use --browser-manual-login (persistent profile) or inline cookies instead.');
+    }
+    const urlsToCheck = Array.from(new Set([stripQuery(targetUrl), ...COOKIE_URLS]));
+    const merged = new Map();
+    const cookieFile = await resolveCookieFilePath({ explicitPath: explicitCookiePath, profile });
+    const cookiesPath = await materializeCookieFile(cookieFile); // returns the copied file (or source on non-Windows)
+    const fallbackDir = await ensureCookiesDirForFallback(cookiesPath);
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] resolved cookie file: ${cookiesPath}`);
+        console.log(`[cookies] fallback dir for chrome-cookies-secure: ${fallbackDir}`);
+    }
+    await ensureMacKeychainReadable();
+    for (const url of urlsToCheck) {
+        let raw;
+        try {
+            const pathForSecure = await adaptPathForChromeCookies(fallbackDir);
+            raw = await settleWithTimeout(chromeCookies.getCookiesPromised(url, 'puppeteer', pathForSecure), COOKIE_READ_TIMEOUT_MS, `Timed out reading Chrome cookies from ${pathForSecure} (after ${COOKIE_READ_TIMEOUT_MS} ms)`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load Chrome cookies for ${url}: ${message}`);
+        }
+        if (!Array.isArray(raw))
+            continue;
+        const fallbackHost = new URL(url).hostname;
+        for (const cookie of raw) {
+            if (filterNames && filterNames.size > 0 && !filterNames.has(cookie.name))
+                continue;
+            const normalized = normalizeCookie(cookie, fallbackHost);
+            if (!normalized)
+                continue;
+            const key = `${normalized.domain ?? fallbackHost}:${normalized.name}`;
+            if (!merged.has(key)) {
+                merged.set(key, normalized);
+            }
+        }
+    }
+    return Array.from(merged.values());
+}
+async function ensureMacKeychainReadable() {
+    if (process.platform === 'win32') {
+        return;
+    }
+    // chrome-cookies-secure can hang forever when the platform keyring rejects access (e.g., SSH/no GUI).
+    // Probe the keyring ourselves with a timeout so callers fail fast instead of blocking the run.
+    let keytar = null;
+    let keytarPath = null;
+    try {
+        const require = createRequire(import.meta.url);
+        keytarPath = require.resolve('keytar');
+        const keytarModule = await import('keytar');
+        keytar = (keytarModule.default ?? keytarModule);
+    }
+    catch (error) {
+        const base = error instanceof Error ? error.message : String(error);
+        const rebuildHint = keytarPath
+            ? ` You may need to rebuild keytar: PYTHON=/usr/bin/python3 /Users/steipete/Projects/oracle/runner npx node-gyp rebuild (run inside ${path.dirname(keytarPath)}).`
+            : '';
+        throw new Error(`Failed to load keytar for secure cookie copy (${base}). Install keyring deps (macOS Keychain / libsecret) or rerun with --render --copy to paste into ChatGPT manually.${rebuildHint}`);
+    }
+    const password = await settleWithTimeout(findKeychainPassword(keytar, MAC_KEYCHAIN_LABELS), KEYCHAIN_PROBE_TIMEOUT_MS, `Timed out reading macOS Keychain while looking up Chrome Safe Storage (after ${KEYCHAIN_PROBE_TIMEOUT_MS} ms). Unlock the login keychain or start oracle serve from a GUI session.`);
+    if (!password) {
+        throw new Error('macOS Keychain denied access to Chrome cookies. Unlock the login keychain or run oracle serve from a GUI session, then retry.');
+    }
+}
+async function findKeychainPassword(keytar, labels) {
+    let lastError = null;
+    for (const label of labels) {
+        try {
+            const value = await keytar.getPassword(label.service, label.account);
+            if (value)
+                return value;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    if (lastError) {
+        throw lastError;
+    }
+    return null;
+}
+function settleWithTimeout(promise, timeoutMs, timeoutMessage) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
+        timer.unref?.();
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function normalizeCookie(cookie, fallbackHost) {
+    if (!cookie?.name)
+        return null;
+    const domain = cookie.domain?.startsWith('.') ? cookie.domain.slice(1) : cookie.domain ?? fallbackHost;
+    const expires = normalizeExpiration(cookie.expires);
+    const secure = typeof cookie.Secure === 'boolean' ? cookie.Secure : true;
+    const httpOnly = typeof cookie.HttpOnly === 'boolean' ? cookie.HttpOnly : false;
+    return {
+        name: cookie.name,
+        value: cleanValue(cookie.value ?? ''),
+        domain,
+        path: cookie.path ?? '/',
+        expires,
+        secure,
+        httpOnly,
+    };
+}
+function cleanValue(value) {
+    let i = 0;
+    while (i < value.length && value.charCodeAt(i) < 0x20)
+        i += 1;
+    return value.slice(i);
+}
+function normalizeExpiration(expires) {
+    if (!expires || Number.isNaN(expires)) {
+        return undefined;
+    }
+    const value = Number(expires);
+    if (value <= 0)
+        return undefined;
+    if (value > 1_000_000_000_000) {
+        return Math.round(value / 1_000_000 - 11644473600);
+    }
+    if (value > 1_000_000_000) {
+        return Math.round(value / 1000);
+    }
+    return Math.round(value);
+}
+async function resolveCookieFilePath({ explicitPath, profile, }) {
+    if (explicitPath && explicitPath.trim().length > 0) {
+        return ensureCookieFile(explicitPath);
+    }
+    if (profile && looksLikePath(profile)) {
+        return ensureCookieFile(profile);
+    }
+    const profileName = profile && profile.trim().length > 0 ? profile : 'Default';
+    const baseDir = await defaultProfileRoot();
+    return ensureCookieFile(path.join(baseDir, profileName));
+}
+async function adaptPathForChromeCookies(resolved) {
+    const stat = await fs.stat(resolved).catch(() => null);
+    if (stat?.isFile()) {
+        // chrome-cookies-secure appends "Cookies" when given a directory; if we already have the file, return its directory.
+        return path.dirname(resolved);
+    }
+    return resolved;
+}
+async function ensureCookieFile(inputPath) {
+    const expanded = expandPath(inputPath);
+    const stat = await fs.stat(expanded).catch(() => null);
+    if (!stat) {
+        throw new Error(`Unable to locate Chrome cookie DB at ${expanded}`);
+    }
+    if (stat.isDirectory()) {
+        const directFile = path.join(expanded, 'Cookies');
+        if (await fileExists(directFile))
+            return directFile;
+        const networkFile = path.join(expanded, 'Network', 'Cookies');
+        if (await fileExists(networkFile))
+            return networkFile;
+        throw new Error(`No Cookies DB found under ${expanded}`);
+    }
+    return expanded;
+}
+async function fileExists(candidate) {
+    try {
+        const stat = await fs.stat(candidate);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function expandPath(input) {
+    if (input.startsWith('~/')) {
+        return path.join(os.homedir(), input.slice(2));
+    }
+    return path.isAbsolute(input) ? input : path.resolve(process.cwd(), input);
+}
+function looksLikePath(value) {
+    return value.includes('/') || value.includes('\\');
+}
+async function materializeCookieFile(sourcePath) {
+    if (process.platform !== 'win32')
+        return sourcePath;
+    // Chrome can keep the Cookies DB locked; copy to a temp file so sqlite can open it reliably.
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-'));
+    const tempPath = path.join(tempDir, 'Cookies');
+    try {
+        await fs.copyFile(sourcePath, tempPath);
+        return tempPath;
+    }
+    catch (_error) {
+        // Fall back to the original path if the copy fails; upstream error handling will surface issues.
+        return sourcePath;
+    }
+}
+async function defaultProfileRoot() {
+    const candidates = [];
+    if (process.platform === 'darwin') {
+        candidates.push(path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome'), path.join(os.homedir(), 'Library', 'Application Support', 'Microsoft Edge'), path.join(os.homedir(), 'Library', 'Application Support', 'Chromium'));
+    }
+    else if (process.platform === 'linux') {
+        if (isWsl()) {
+            const windowsHomes = [process.env.USERPROFILE, process.env.WIN_HOME, process.env.HOME?.replace('/home', '/mnt/c/Users')]
+                .filter((p) => Boolean(p))
+                .map((p) => p.replace(/\\/g, '/'));
+            const wslCandidates = [];
+            for (const home of windowsHomes) {
+                const normalized = home.startsWith('/mnt/') ? home : `/mnt/c/Users/${path.basename(home)}`;
+                wslCandidates.push(path.join(normalized, 'AppData', 'Local', 'Google', 'Chrome', 'User Data'), path.join(normalized, 'AppData', 'Local', 'Microsoft', 'Edge', 'User Data'));
+            }
+            // Ensure we don't pick a non-user Default profile ahead of real ones.
+            for (const candidate of wslCandidates) {
+                const hasProfile = existsSync(path.join(candidate, 'Default'));
+                if (hasProfile) {
+                    candidates.push(candidate);
+                }
+            }
+        }
+        candidates.push(path.join(os.homedir(), '.config', 'google-chrome'), path.join(os.homedir(), '.config', 'microsoft-edge'), path.join(os.homedir(), '.config', 'chromium'), 
+        // Snap Chromium profiles
+        path.join(os.homedir(), 'snap', 'chromium', 'common', 'chromium'), path.join(os.homedir(), 'snap', 'chromium', 'current', 'chromium'));
+    }
+    else if (process.platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+        candidates.push(path.join(localAppData, 'Google', 'Chrome', 'User Data'), path.join(localAppData, 'Microsoft', 'Edge', 'User Data'), path.join(localAppData, 'Chromium', 'User Data'));
+    }
+    else {
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // fallback: first candidate even if missing; upstream will throw clearer error
+    return candidates[0];
+}
+function stripQuery(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.hash = '';
+        parsed.search = '';
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+}
+function readDuration(envKey, fallback) {
+    const raw = process.env[envKey];
+    if (!raw)
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    return Boolean(process.env.WSL_DISTRO_NAME || os.release().toLowerCase().includes('microsoft'));
+}
+function loadKeychainLabels() {
+    const defaults = [
+        { service: 'Chrome Safe Storage', account: 'Chrome' },
+        { service: 'Chromium Safe Storage', account: 'Chromium' },
+        { service: 'Microsoft Edge Safe Storage', account: 'Microsoft Edge' },
+        { service: 'Brave Safe Storage', account: 'Brave' },
+        { service: 'Vivaldi Safe Storage', account: 'Vivaldi' },
+    ];
+    const rawEnv = process.env.ORACLE_KEYCHAIN_LABELS;
+    if (!rawEnv)
+        return defaults;
+    try {
+        const parsed = JSON.parse(rawEnv);
+        if (!Array.isArray(parsed))
+            return defaults;
+        const envLabels = parsed
+            .map((entry) => (entry && typeof entry === 'object' ? entry : null))
+            .filter((entry) => Boolean(entry?.service && entry?.account));
+        return envLabels.length ? [...envLabels, ...defaults] : defaults;
+    }
+    catch {
+        return defaults;
+    }
+}
+// biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
+export const __test__ = {
+    normalizeExpiration,
+    cleanValue,
+    looksLikePath,
+    defaultProfileRoot,
+};

package/dist/src/browser/config.js

@@ -35,7 +35,7 @@ export const DEFAULT_BROWSER_CONFIG = {
     autoReattachDelayMs: 0,
     autoReattachIntervalMs: 0,
     autoReattachTimeoutMs: 120_000,
-    cookieSync: true,
+    cookieSync: false,
     cookieNames: DEFAULT_CHATGPT_COOKIE_NAMES,
     cookieSyncWaitMs: 0,
     inlineCookies: null,
@@ -70,7 +70,6 @@ export function resolveBrowserConfig(config) {
         DEFAULT_MODEL_STRATEGY;
     const isWindows = process.platform === "win32";
     const manualLogin = config?.manualLogin ?? (isWindows ? true : DEFAULT_BROWSER_CONFIG.manualLogin);
-    const cookieSyncDefault = isWindows ? false : DEFAULT_BROWSER_CONFIG.cookieSync;
     const resolvedProfileDir = resolveManualLoginProfileDir(config?.manualLoginProfileDir, process.env.ORACLE_BROWSER_PROFILE_DIR);
     const researchMode = normalizeResearchMode(config?.researchMode);
     const archiveConversations = normalizeArchiveMode(config?.archiveConversations);
@@ -92,7 +91,7 @@ export function resolveBrowserConfig(config) {
         autoReattachDelayMs: config?.autoReattachDelayMs ?? DEFAULT_BROWSER_CONFIG.autoReattachDelayMs,
         autoReattachIntervalMs: config?.autoReattachIntervalMs ?? DEFAULT_BROWSER_CONFIG.autoReattachIntervalMs,
         autoReattachTimeoutMs: config?.autoReattachTimeoutMs ?? DEFAULT_BROWSER_CONFIG.autoReattachTimeoutMs,
-        cookieSync: config?.cookieSync ?? cookieSyncDefault,
+        cookieSync: config?.cookieSync ?? DEFAULT_BROWSER_CONFIG.cookieSync,
         cookieNames: config?.cookieNames ?? DEFAULT_BROWSER_CONFIG.cookieNames,
         cookieSyncWaitMs: config?.cookieSyncWaitMs ?? DEFAULT_BROWSER_CONFIG.cookieSyncWaitMs,
         inlineCookies: config?.inlineCookies ?? DEFAULT_BROWSER_CONFIG.inlineCookies,

package/dist/src/browser/index.js

@@ -32,6 +32,7 @@ import { captureBrowserDiagnostics } from "./domDebug.js";
 import { archiveChatGptConversation, resolveBrowserArchiveDecision, } from "./actions/archiveConversation.js";
 import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, isManualLoginProfileInitialized, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { describeBrowserControlPlan, formatBrowserControlPlan } from "./controlPlan.js";
+import { CHROME_COOKIE_SYNC_WARNING, shouldSyncBrowserCookies } from "./policies.js";
 import { createConversationUrlMonitor, } from "./conversationUrlMonitor.js";
 import { extractStableConversationIdFromUrl as extractConversationIdFromUrl, isStableConversationUrl as isConversationUrl, } from "./conversationUrl.js";
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
@@ -864,12 +865,16 @@ export async function runBrowserMode(options) {
             await Network.clearBrowserCookies();
         }
         const manualLoginCookieSync = manualLogin && Boolean(config.manualLoginCookieSync);
-        const cookieSyncEnabled = config.cookieSync && (!profileIsPreSigned || manualLoginCookieSync);
+        const cookieSyncEnabled = shouldSyncBrowserCookies(config, {
+            manualLogin,
+            profileIsPreSigned,
+        });
         if (cookieSyncEnabled) {
             if (manualLoginCookieSync) {
                 logger("Manual login mode: seeding persistent profile with cookies from your Chrome profile.");
             }
             if (!config.inlineCookies) {
+                logger(CHROME_COOKIE_SYNC_WARNING);
                 logger("Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; use --copy or --render for manual flow.");
             }
             else {
@@ -898,7 +903,7 @@ export async function runBrowserMode(options) {
         else {
             logger(manualLogin
                 ? "Skipping Chrome cookie sync (--browser-manual-login enabled); reuse the opened profile after signing in."
-                : "Skipping Chrome cookie sync (--browser-no-cookie-sync)");
+                : "Skipping Chrome cookie copy (disabled by default; use --browser-cookie-sync to opt in).");
         }
         await clearStaleChatGptConversationCookies(Network, Target, logger, {
             preserveConversationIds: [