@indykish/oracle 0.9.0

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

@@ -0,0 +1,206 @@
+import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR } from '../constants.js';
+import { logDomFailure } from '../domDebug.js';
+import { buildClickDispatcher } from './domEvents.js';
+/**
+ * Selects a specific thinking time level in ChatGPT's composer pill menu.
+ * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
+ */
+export async function ensureThinkingTime(Runtime, level, logger) {
+    const result = await evaluateThinkingTimeSelection(Runtime, level);
+    const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
+    switch (result?.status) {
+        case 'already-selected':
+            logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
+            return;
+        case 'switched':
+            logger(`Thinking time: ${result.label ?? capitalizedLevel}`);
+            return;
+        case 'chip-not-found': {
+            await logDomFailure(Runtime, logger, 'thinking-chip');
+            throw new Error('Unable to find the Thinking chip button in the composer area.');
+        }
+        case 'menu-not-found': {
+            await logDomFailure(Runtime, logger, 'thinking-time-menu');
+            throw new Error('Unable to find the Thinking time dropdown menu.');
+        }
+        case 'option-not-found': {
+            await logDomFailure(Runtime, logger, `${level}-option`);
+            throw new Error(`Unable to find the ${capitalizedLevel} option in the Thinking time menu.`);
+        }
+        default: {
+            await logDomFailure(Runtime, logger, 'thinking-time-unknown');
+            throw new Error(`Unknown error selecting ${capitalizedLevel} thinking time.`);
+        }
+    }
+}
+/**
+ * Best-effort selection of a thinking time level in ChatGPT's composer pill menu.
+ * Safe by default: if the pill/menu/option isn't present, we continue without throwing.
+ * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
+ */
+export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
+    try {
+        const result = await evaluateThinkingTimeSelection(Runtime, level);
+        const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
+        switch (result?.status) {
+            case 'already-selected':
+                logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
+                return true;
+            case 'switched':
+                logger(`Thinking time: ${result.label ?? capitalizedLevel}`);
+                return true;
+            case 'chip-not-found':
+            case 'menu-not-found':
+            case 'option-not-found':
+                if (logger.verbose) {
+                    logger(`Thinking time: ${result.status.replaceAll('-', ' ')}; continuing with default.`);
+                }
+                return false;
+            default:
+                if (logger.verbose) {
+                    logger('Thinking time: unknown outcome; continuing with default.');
+                }
+                return false;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (logger.verbose) {
+            logger(`Thinking time selection failed (${message}); continuing with default.`);
+            await logDomFailure(Runtime, logger, 'thinking-time');
+        }
+        return false;
+    }
+}
+async function evaluateThinkingTimeSelection(Runtime, level) {
+    const outcome = await Runtime.evaluate({
+        expression: buildThinkingTimeExpression(level),
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    return outcome.result?.value;
+}
+function buildThinkingTimeExpression(level) {
+    const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
+    const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
+    const targetLevelLiteral = JSON.stringify(level.toLowerCase());
+    return `(async () => {
+    ${buildClickDispatcher()}
+
+    const MENU_CONTAINER_SELECTOR = ${menuContainerLiteral};
+    const MENU_ITEM_SELECTOR = ${menuItemLiteral};
+    const TARGET_LEVEL = ${targetLevelLiteral};
+
+    const CHIP_SELECTORS = [
+      '[data-testid="composer-footer-actions"] button[aria-haspopup="menu"]',
+      'button.__composer-pill[aria-haspopup="menu"]',
+      '.__composer-pill-composite button[aria-haspopup="menu"]',
+    ];
+
+    const INITIAL_WAIT_MS = 150;
+    const MAX_WAIT_MS = 10000;
+
+    const normalize = (value) => (value || '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, ' ')
+      .replace(/\\s+/g, ' ')
+      .trim();
+
+    const findThinkingChip = () => {
+      for (const selector of CHIP_SELECTORS) {
+        const buttons = document.querySelectorAll(selector);
+        for (const btn of buttons) {
+          // Skip toggle buttons (no haspopup) - only click dropdown triggers to avoid disabling Pro mode
+          if (btn.getAttribute?.('aria-haspopup') !== 'menu') continue;
+          const aria = normalize(btn.getAttribute?.('aria-label') ?? '');
+          const text = normalize(btn.textContent ?? '');
+          if (aria.includes('thinking') || text.includes('thinking')) {
+            return btn;
+          }
+
+          // In some cases the pill is labeled "Pro".
+          if (aria.includes('pro') || text.includes('pro')) {
+            return btn;
+          }
+        }
+      }
+      return null;
+    };
+
+    const chip = findThinkingChip();
+    if (!chip) {
+      return { status: 'chip-not-found' };
+    }
+
+    dispatchClickSequence(chip);
+
+    return new Promise((resolve) => {
+      const start = performance.now();
+
+      const findMenu = () => {
+        const menus = document.querySelectorAll(MENU_CONTAINER_SELECTOR + ', [role="group"]');
+        for (const menu of menus) {
+          const label = menu.querySelector?.('.__menu-label, [class*="menu-label"]');
+          if (normalize(label?.textContent ?? '').includes('thinking time')) {
+            return menu;
+          }
+          const text = normalize(menu.textContent ?? '');
+          if (text.includes('standard') && text.includes('extended')) {
+            return menu;
+          }
+        }
+        return null;
+      };
+
+      const findTargetOption = (menu) => {
+        const items = menu.querySelectorAll(MENU_ITEM_SELECTOR);
+        for (const item of items) {
+          const text = normalize(item.textContent ?? '');
+          if (text.includes(TARGET_LEVEL)) {
+            return item;
+          }
+        }
+        return null;
+      };
+
+      const optionIsSelected = (node) => {
+        if (!(node instanceof HTMLElement)) return false;
+        const ariaChecked = node.getAttribute('aria-checked');
+        const dataState = (node.getAttribute('data-state') || '').toLowerCase();
+        if (ariaChecked === 'true') return true;
+        if (dataState === 'checked' || dataState === 'selected' || dataState === 'on') return true;
+        return false;
+      };
+
+      const attempt = () => {
+        const menu = findMenu();
+        if (!menu) {
+          if (performance.now() - start > MAX_WAIT_MS) {
+            resolve({ status: 'menu-not-found' });
+            return;
+          }
+          setTimeout(attempt, 100);
+          return;
+        }
+
+        const targetOption = findTargetOption(menu);
+        if (!targetOption) {
+          resolve({ status: 'option-not-found' });
+          return;
+        }
+
+        const alreadySelected =
+          optionIsSelected(targetOption) ||
+          optionIsSelected(targetOption.querySelector?.('[aria-checked="true"], [data-state="checked"], [data-state="selected"]'));
+        const label = targetOption.textContent?.trim?.() || null;
+        dispatchClickSequence(targetOption);
+        resolve({ status: alreadySelected ? 'already-selected' : 'switched', label });
+      };
+
+      setTimeout(attempt, INITIAL_WAIT_MS);
+    });
+  })()`;
+}
+export function buildThinkingTimeExpressionForTest(level = 'extended') {
+    return buildThinkingTimeExpression(level);
+}

package/dist/src/browser/chromeLifecycle.js

@@ -0,0 +1,344 @@
+import { rm } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import net from 'node:net';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import CDP from 'chrome-remote-interface';
+import { launch, Launcher } from 'chrome-launcher';
+import { cleanupStaleProfileState } from './profileState.js';
+import { delay } from './utils.js';
+const execFileAsync = promisify(execFile);
+export async function launchChrome(config, userDataDir, logger) {
+    const connectHost = resolveRemoteDebugHost();
+    const debugBindAddress = connectHost && connectHost !== '127.0.0.1' ? '0.0.0.0' : connectHost;
+    const debugPort = config.debugPort ?? parseDebugPortEnv();
+    const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress);
+    const usePatchedLauncher = Boolean(connectHost && connectHost !== '127.0.0.1');
+    const launcher = usePatchedLauncher
+        ? await launchWithCustomHost({
+            chromeFlags,
+            chromePath: config.chromePath ?? undefined,
+            userDataDir,
+            host: connectHost ?? '127.0.0.1',
+            requestedPort: debugPort ?? undefined,
+        })
+        : await launch({
+            chromePath: config.chromePath ?? undefined,
+            chromeFlags,
+            userDataDir,
+            handleSIGINT: false,
+            port: debugPort ?? undefined,
+        });
+    const pidLabel = typeof launcher.pid === 'number' ? ` (pid ${launcher.pid})` : '';
+    const hostLabel = connectHost ? ` on ${connectHost}` : '';
+    logger(`Launched Chrome${pidLabel} on port ${launcher.port}${hostLabel}`);
+    return Object.assign(launcher, { host: connectHost ?? '127.0.0.1' });
+}
+export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logger, opts) {
+    const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
+    let handling;
+    const handleSignal = (signal) => {
+        if (handling) {
+            return;
+        }
+        handling = true;
+        const inFlight = opts?.isInFlight?.() ?? false;
+        const leaveRunning = keepBrowser || inFlight;
+        if (leaveRunning) {
+            logger(`Received ${signal}; leaving Chrome running${inFlight ? ' (assistant response pending)' : ''}`);
+        }
+        else {
+            logger(`Received ${signal}; terminating Chrome process`);
+        }
+        void (async () => {
+            if (leaveRunning) {
+                // Ensure reattach hints are written before we exit.
+                await opts?.emitRuntimeHint?.().catch(() => undefined);
+                if (inFlight) {
+                    logger('Session still in flight; reattach with "oracle session <slug>" to continue.');
+                }
+            }
+            else {
+                try {
+                    await chrome.kill();
+                }
+                catch {
+                    // ignore kill failures
+                }
+                if (opts?.preserveUserDataDir) {
+                    // Preserve the profile directory (manual login), but clear reattach hints so we don't
+                    // try to reuse a dead DevTools port on the next run.
+                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'never' }).catch(() => undefined);
+                }
+                else {
+                    await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+                }
+            }
+        })().finally(() => {
+            const exitCode = signal === 'SIGINT' ? 130 : 1;
+            // Vitest treats any `process.exit()` call as an unhandled failure, even if mocked.
+            // Keep production behavior (hard-exit on signals) while letting tests observe state changes.
+            process.exitCode = exitCode;
+            const isTestRun = process.env.VITEST === '1' || process.env.NODE_ENV === 'test';
+            if (!isTestRun) {
+                process.exit(exitCode);
+            }
+        });
+    };
+    for (const signal of signals) {
+        process.on(signal, handleSignal);
+    }
+    return () => {
+        for (const signal of signals) {
+            process.removeListener(signal, handleSignal);
+        }
+    };
+}
+export async function hideChromeWindow(chrome, logger) {
+    if (process.platform !== 'darwin') {
+        logger('Window hiding is only supported on macOS');
+        return;
+    }
+    if (!chrome.pid) {
+        logger('Unable to hide window: missing Chrome PID');
+        return;
+    }
+    const script = `tell application "System Events"
+    try
+      set visible of (first process whose unix id is ${chrome.pid}) to false
+    end try
+  end tell`;
+    try {
+        await execFileAsync('osascript', ['-e', script]);
+        logger('Chrome window hidden (Cmd-H)');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to hide Chrome window: ${message}`);
+    }
+}
+export async function connectToChrome(port, logger, host) {
+    const client = await CDP({ port, host });
+    logger('Connected to Chrome DevTools protocol');
+    return client;
+}
+export async function connectToRemoteChrome(host, port, logger, targetUrl) {
+    if (targetUrl) {
+        const targetConnection = await connectToNewTarget(host, port, targetUrl, logger, {
+            opened: () => `Opened dedicated remote Chrome tab targeting ${targetUrl}`,
+            openFailed: (message) => `Failed to open dedicated remote Chrome tab (${message}); falling back to first target.`,
+            attachFailed: (targetId, message) => `Failed to attach to dedicated remote Chrome tab ${targetId} (${message}); falling back to first target.`,
+            closeFailed: (targetId, message) => `Failed to close unused remote Chrome tab ${targetId}: ${message}`,
+        });
+        if (targetConnection) {
+            return { client: targetConnection.client, targetId: targetConnection.targetId };
+        }
+    }
+    const fallbackClient = await CDP({ host, port });
+    logger(`Connected to remote Chrome DevTools protocol at ${host}:${port}`);
+    return { client: fallbackClient };
+}
+export async function closeRemoteChromeTarget(host, port, targetId, logger) {
+    if (!targetId) {
+        return;
+    }
+    try {
+        await CDP.Close({ host, port, id: targetId });
+        if (logger.verbose) {
+            logger(`Closed remote Chrome tab ${targetId}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to close remote Chrome tab ${targetId}: ${message}`);
+    }
+}
+async function connectToNewTarget(host, port, url, logger, messages) {
+    try {
+        const target = await CDP.New({ host, port, url });
+        try {
+            const client = await CDP({ host, port, target: target.id });
+            if (messages.opened) {
+                logger(messages.opened(target.id));
+            }
+            return { client, targetId: target.id };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger(messages.attachFailed(target.id, message));
+            try {
+                await CDP.Close({ host, port, id: target.id });
+            }
+            catch (closeError) {
+                const closeMessage = closeError instanceof Error ? closeError.message : String(closeError);
+                logger(messages.closeFailed(target.id, closeMessage));
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(messages.openFailed(message));
+    }
+    return null;
+}
+export async function connectWithNewTab(port, logger, initialUrl, host, options) {
+    const effectiveHost = host ?? '127.0.0.1';
+    const url = initialUrl ?? 'about:blank';
+    const fallbackToDefault = options?.fallbackToDefault ?? true;
+    const retries = Math.max(0, options?.retries ?? 0);
+    const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 250);
+    const fallbackLabel = fallbackToDefault ? 'falling back to default target.' : 'strict mode: not falling back.';
+    let attempt = 0;
+    while (attempt <= retries) {
+        const targetConnection = await connectToNewTarget(effectiveHost, port, url, logger, {
+            opened: (targetId) => `Opened isolated browser tab (target=${targetId})`,
+            openFailed: (message) => `Failed to open isolated browser tab (${message}); ${fallbackLabel}`,
+            attachFailed: (targetId, message) => `Failed to attach to isolated browser tab ${targetId} (${message}); ${fallbackLabel}`,
+            closeFailed: (targetId, message) => `Failed to close unused browser tab ${targetId}: ${message}`,
+        });
+        if (targetConnection) {
+            return targetConnection;
+        }
+        if (attempt >= retries) {
+            break;
+        }
+        attempt += 1;
+        await delay(retryDelayMs * attempt);
+    }
+    if (!fallbackToDefault) {
+        throw new Error('Failed to open isolated browser tab; refusing to attach to default target.');
+    }
+    const client = await connectToChrome(port, logger, effectiveHost);
+    return { client };
+}
+export async function closeTab(port, targetId, logger, host) {
+    const effectiveHost = host ?? '127.0.0.1';
+    try {
+        await CDP.Close({ host: effectiveHost, port, id: targetId });
+        logger(`Closed isolated browser tab (target=${targetId})`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to close browser tab ${targetId}: ${message}`);
+    }
+}
+function buildChromeFlags(headless, debugBindAddress) {
+    const flags = [
+        '--disable-background-networking',
+        '--disable-background-timer-throttling',
+        '--disable-breakpad',
+        '--disable-client-side-phishing-detection',
+        '--disable-default-apps',
+        '--disable-hang-monitor',
+        '--disable-popup-blocking',
+        '--disable-prompt-on-repost',
+        '--disable-sync',
+        '--disable-translate',
+        '--metrics-recording-only',
+        '--no-first-run',
+        '--safebrowsing-disable-auto-update',
+        '--disable-features=TranslateUI,AutomationControlled',
+        '--mute-audio',
+        '--window-size=1280,720',
+        '--lang=en-US',
+        '--accept-lang=en-US,en',
+    ];
+    if (process.platform !== 'win32' && !isWsl()) {
+        flags.push('--password-store=basic', '--use-mock-keychain');
+    }
+    if (debugBindAddress) {
+        flags.push(`--remote-debugging-address=${debugBindAddress}`);
+    }
+    if (headless) {
+        flags.push('--headless=new');
+    }
+    return flags;
+}
+function parseDebugPortEnv() {
+    const raw = process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT;
+    if (!raw)
+        return null;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value <= 0 || value > 65535) {
+        return null;
+    }
+    return value;
+}
+function resolveRemoteDebugHost() {
+    const override = process.env.ORACLE_BROWSER_REMOTE_DEBUG_HOST?.trim() || process.env.WSL_HOST_IP?.trim();
+    if (override) {
+        return override;
+    }
+    if (!isWsl()) {
+        return null;
+    }
+    try {
+        const resolv = readFileSync('/etc/resolv.conf', 'utf8');
+        for (const line of resolv.split('\n')) {
+            const match = line.match(/^nameserver\s+([0-9.]+)/);
+            if (match?.[1]) {
+                return match[1];
+            }
+        }
+    }
+    catch {
+        // ignore; fall back to localhost
+    }
+    return null;
+}
+function isWsl() {
+    if (process.platform !== 'linux') {
+        return false;
+    }
+    if (process.env.WSL_DISTRO_NAME) {
+        return true;
+    }
+    const release = os.release();
+    return release.toLowerCase().includes('microsoft');
+}
+async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host, requestedPort, }) {
+    const launcher = new Launcher({
+        chromePath: chromePath ?? undefined,
+        chromeFlags,
+        userDataDir,
+        handleSIGINT: false,
+        port: requestedPort ?? undefined,
+    });
+    if (host) {
+        const patched = launcher;
+        patched.isDebuggerReady = function patchedIsDebuggerReady() {
+            const debugPort = this.port ?? 0;
+            if (!debugPort) {
+                return Promise.reject(new Error('Missing Chrome debug port'));
+            }
+            return new Promise((resolve, reject) => {
+                const client = net.createConnection({ port: debugPort, host });
+                const cleanup = () => {
+                    client.removeAllListeners();
+                    client.end();
+                    client.destroy();
+                    client.unref();
+                };
+                client.once('error', (err) => {
+                    cleanup();
+                    reject(err);
+                });
+                client.once('connect', () => {
+                    cleanup();
+                    resolve();
+                });
+            });
+        };
+    }
+    await launcher.launch();
+    const kill = async () => launcher.kill();
+    return {
+        pid: launcher.pid ?? undefined,
+        port: launcher.port ?? 0,
+        process: launcher.chromeProcess,
+        kill,
+        host: host ?? undefined,
+        remoteDebuggingPipes: launcher.remoteDebuggingPipes,
+    };
+}

package/dist/src/browser/config.js

@@ -0,0 +1,103 @@
+import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from './constants.js';
+import { normalizeBrowserModelStrategy } from './modelStrategy.js';
+import { isTemporaryChatUrl, normalizeChatgptUrl } from './utils.js';
+import os from 'node:os';
+import path from 'node:path';
+export const DEFAULT_BROWSER_CONFIG = {
+    chromeProfile: null,
+    chromePath: null,
+    chromeCookiePath: null,
+    url: CHATGPT_URL,
+    chatgptUrl: CHATGPT_URL,
+    timeoutMs: 1_200_000,
+    debugPort: null,
+    inputTimeoutMs: 60_000,
+    assistantRecheckDelayMs: 0,
+    assistantRecheckTimeoutMs: 120_000,
+    reuseChromeWaitMs: 10_000,
+    profileLockTimeoutMs: 300_000,
+    autoReattachDelayMs: 0,
+    autoReattachIntervalMs: 0,
+    autoReattachTimeoutMs: 120_000,
+    cookieSync: true,
+    cookieNames: null,
+    cookieSyncWaitMs: 0,
+    inlineCookies: null,
+    inlineCookiesSource: null,
+    headless: false,
+    keepBrowser: false,
+    hideWindow: false,
+    desiredModel: DEFAULT_MODEL_TARGET,
+    modelStrategy: DEFAULT_MODEL_STRATEGY,
+    debug: false,
+    allowCookieErrors: false,
+    remoteChrome: null,
+    manualLogin: false,
+    manualLoginProfileDir: null,
+    manualLoginCookieSync: false,
+};
+export function resolveBrowserConfig(config) {
+    const debugPortEnv = parseDebugPort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT);
+    const envAllowCookieErrors = (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? '').trim().toLowerCase() === 'true' ||
+        (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? '').trim() === '1';
+    const rawUrl = config?.chatgptUrl ?? config?.url ?? DEFAULT_BROWSER_CONFIG.url;
+    const normalizedUrl = normalizeChatgptUrl(rawUrl ?? DEFAULT_BROWSER_CONFIG.url, DEFAULT_BROWSER_CONFIG.url);
+    const desiredModel = config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel ?? DEFAULT_MODEL_TARGET;
+    const modelStrategy = normalizeBrowserModelStrategy(config?.modelStrategy) ??
+        DEFAULT_BROWSER_CONFIG.modelStrategy ??
+        DEFAULT_MODEL_STRATEGY;
+    if (modelStrategy === 'select' && isTemporaryChatUrl(normalizedUrl) && /\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 your browser URL, or use a non-Pro model label (e.g. "GPT-5.2").');
+    }
+    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 = config?.manualLoginProfileDir ??
+        process.env.ORACLE_BROWSER_PROFILE_DIR ??
+        path.join(os.homedir(), '.oracle', 'browser-profile');
+    return {
+        ...DEFAULT_BROWSER_CONFIG,
+        ...(config ?? {}),
+        url: normalizedUrl,
+        chatgptUrl: normalizedUrl,
+        timeoutMs: config?.timeoutMs ?? DEFAULT_BROWSER_CONFIG.timeoutMs,
+        debugPort: config?.debugPort ?? debugPortEnv ?? DEFAULT_BROWSER_CONFIG.debugPort,
+        inputTimeoutMs: config?.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs,
+        assistantRecheckDelayMs: config?.assistantRecheckDelayMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckDelayMs,
+        assistantRecheckTimeoutMs: config?.assistantRecheckTimeoutMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckTimeoutMs,
+        reuseChromeWaitMs: config?.reuseChromeWaitMs ?? DEFAULT_BROWSER_CONFIG.reuseChromeWaitMs,
+        profileLockTimeoutMs: config?.profileLockTimeoutMs ?? DEFAULT_BROWSER_CONFIG.profileLockTimeoutMs,
+        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,
+        cookieNames: config?.cookieNames ?? DEFAULT_BROWSER_CONFIG.cookieNames,
+        cookieSyncWaitMs: config?.cookieSyncWaitMs ?? DEFAULT_BROWSER_CONFIG.cookieSyncWaitMs,
+        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,
+        desiredModel,
+        modelStrategy,
+        chromeProfile: config?.chromeProfile ?? DEFAULT_BROWSER_CONFIG.chromeProfile,
+        chromePath: config?.chromePath ?? DEFAULT_BROWSER_CONFIG.chromePath,
+        chromeCookiePath: config?.chromeCookiePath ?? DEFAULT_BROWSER_CONFIG.chromeCookiePath,
+        debug: config?.debug ?? DEFAULT_BROWSER_CONFIG.debug,
+        allowCookieErrors: config?.allowCookieErrors ?? envAllowCookieErrors ?? DEFAULT_BROWSER_CONFIG.allowCookieErrors,
+        thinkingTime: config?.thinkingTime,
+        manualLogin,
+        manualLoginProfileDir: manualLogin ? resolvedProfileDir : null,
+        manualLoginCookieSync: config?.manualLoginCookieSync ?? DEFAULT_BROWSER_CONFIG.manualLoginCookieSync,
+    };
+}
+function parseDebugPort(raw) {
+    if (!raw)
+        return null;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value) || value <= 0 || value > 65535) {
+        return null;
+    }
+    return value;
+}