@steipete/oracle 0.4.5 → 0.5.0

package/dist/src/browser/index.js

@@ -1,14 +1,15 @@
-import { mkdtemp, rm } from 'node:fs/promises';
+import { mkdtemp, rm, mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import { resolveBrowserConfig } from './config.js';
-import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChrome, connectToRemoteChrome, } from './chromeLifecycle.js';
+import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChrome, connectToRemoteChrome, closeRemoteChromeTarget, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
 import { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, readAssistantSnapshot, } from './pageActions.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
-import { estimateTokenCount, withRetries } from './utils.js';
+import { estimateTokenCount, withRetries, delay } from './utils.js';
 import { formatElapsed } from '../oracle/format.js';
 import { CHATGPT_URL } from './constants.js';
+import { BrowserAutomationError } from '../oracle/errors.js';
 export { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
 export { parseDuration, delay, normalizeChatgptUrl } from './utils.js';
 export async function runBrowserMode(options) {
@@ -25,6 +26,30 @@ export async function runBrowserMode(options) {
     if (logger.sessionLog === undefined && options.log?.sessionLog) {
         logger.sessionLog = options.log.sessionLog;
     }
+    const runtimeHintCb = options.runtimeHintCb;
+    let lastTargetId;
+    let lastUrl;
+    const emitRuntimeHint = async () => {
+        if (!runtimeHintCb || !chrome?.port) {
+            return;
+        }
+        const hint = {
+            chromePid: chrome.pid,
+            chromePort: chrome.port,
+            chromeHost,
+            chromeTargetId: lastTargetId,
+            tabUrl: lastUrl,
+            userDataDir,
+            controllerPid: process.pid,
+        };
+        try {
+            await runtimeHintCb(hint);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger(`Failed to persist runtime hint: ${message}`);
+        }
+    };
     if (config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') {
         logger(`[browser-mode] config: ${JSON.stringify({
             ...config,
@@ -40,12 +65,31 @@ export async function runBrowserMode(options) {
         }
         return runRemoteBrowserMode(promptText, attachments, config, logger, options);
     }
-    const userDataDir = await mkdtemp(path.join(os.tmpdir(), 'oracle-browser-'));
-    logger(`Created temporary Chrome profile at ${userDataDir}`);
-    const chrome = await launchChrome(config, userDataDir, logger);
+    const manualLogin = Boolean(config.manualLogin);
+    const manualProfileDir = config.manualLoginProfileDir
+        ? path.resolve(config.manualLoginProfileDir)
+        : path.join(os.homedir(), '.oracle', 'browser-profile');
+    const userDataDir = manualLogin
+        ? manualProfileDir
+        : await mkdtemp(path.join(await resolveUserDataBaseDir(), 'oracle-browser-'));
+    if (manualLogin) {
+        await mkdir(userDataDir, { recursive: true });
+        logger(`Manual login mode enabled; reusing persistent profile at ${userDataDir}`);
+    }
+    else {
+        logger(`Created temporary Chrome profile at ${userDataDir}`);
+    }
+    const effectiveKeepBrowser = config.keepBrowser || manualLogin;
+    const reusedChrome = manualLogin ? await maybeReuseRunningChrome(userDataDir, logger) : null;
+    const chrome = reusedChrome ??
+        (await launchChrome({
+            ...config,
+            remoteChrome: config.remoteChrome,
+        }, userDataDir, logger));
+    const chromeHost = chrome.host ?? '127.0.0.1';
     let removeTerminationHooks = null;
     try {
-        removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, config.keepBrowser, logger);
+        removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, effectiveKeepBrowser, logger);
     }
     catch {
         // ignore failure; cleanup still happens below
@@ -60,7 +104,16 @@ export async function runBrowserMode(options) {
     let stopThinkingMonitor = null;
     let appliedCookies = 0;
     try {
-        client = await connectToChrome(chrome.port, logger);
+        try {
+            client = await connectToChrome(chrome.port, logger, chromeHost);
+        }
+        catch (error) {
+            const hint = describeDevtoolsFirewallHint(chromeHost, chrome.port);
+            if (hint) {
+                logger(hint);
+            }
+            throw error;
+        }
         const disconnectPromise = new Promise((_, reject) => {
             client?.on('disconnect', () => {
                 connectionClosedUnexpectedly = true;
@@ -78,8 +131,11 @@ export async function runBrowserMode(options) {
             domainEnablers.push(DOM.enable());
         }
         await Promise.all(domainEnablers);
-        await Network.clearBrowserCookies();
-        if (config.cookieSync) {
+        if (!manualLogin) {
+            await Network.clearBrowserCookies();
+        }
+        const cookieSyncEnabled = config.cookieSync && !manualLogin;
+        if (cookieSyncEnabled) {
             if (!config.inlineCookies) {
                 logger('Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; use --copy or --render for manual flow.');
             }
@@ -105,20 +161,57 @@ export async function runBrowserMode(options) {
                     : 'No Chrome cookies found; continuing without session reuse');
         }
         else {
-            logger('Skipping Chrome cookie sync (--browser-no-cookie-sync)');
+            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)');
         }
         const baseUrl = CHATGPT_URL;
         // First load the base ChatGPT homepage to satisfy potential interstitials,
         // then hop to the requested URL if it differs.
         await raceWithDisconnect(navigateToChatGPT(Page, Runtime, baseUrl, logger));
         await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
-        await raceWithDisconnect(ensureLoggedIn(Runtime, logger, { appliedCookies }));
+        await raceWithDisconnect(waitForLogin({ runtime: Runtime, logger, appliedCookies, manualLogin, timeoutMs: config.timeoutMs }));
         if (config.url !== baseUrl) {
             await raceWithDisconnect(navigateToChatGPT(Page, Runtime, config.url, logger));
             await raceWithDisconnect(ensureNotBlocked(Runtime, config.headless, logger));
         }
         await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
+        const captureRuntimeSnapshot = async () => {
+            try {
+                if (client?.Target?.getTargetInfo) {
+                    const info = await client.Target.getTargetInfo({});
+                    lastTargetId = info?.targetInfo?.targetId ?? lastTargetId;
+                    lastUrl = info?.targetInfo?.url ?? lastUrl;
+                }
+            }
+            catch {
+                // ignore
+            }
+            try {
+                const { result } = await Runtime.evaluate({
+                    expression: 'location.href',
+                    returnByValue: true,
+                });
+                if (typeof result?.value === 'string') {
+                    lastUrl = result.value;
+                }
+            }
+            catch {
+                // ignore
+            }
+            if (chrome?.port) {
+                const suffix = lastTargetId ? ` target=${lastTargetId}` : '';
+                if (lastUrl) {
+                    logger(`[reattach] chrome port=${chrome.port} host=${chromeHost} url=${lastUrl}${suffix}`);
+                }
+                else {
+                    logger(`[reattach] chrome port=${chrome.port} host=${chromeHost}${suffix}`);
+                }
+                await emitRuntimeHint();
+            }
+        };
+        await captureRuntimeSnapshot();
         if (config.desiredModel) {
             await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger), {
                 retries: 2,
@@ -223,7 +316,11 @@ export async function runBrowserMode(options) {
             answerChars,
             chromePid: chrome.pid,
             chromePort: chrome.port,
+            chromeHost,
             userDataDir,
+            chromeTargetId: lastTargetId,
+            tabUrl: lastUrl,
+            controllerPid: process.pid,
         };
     }
     catch (error) {
@@ -242,9 +339,19 @@ export async function runBrowserMode(options) {
             logger(`Chrome window closed before completion: ${normalizedError.message}`);
             logger(normalizedError.stack);
         }
-        throw new Error('Chrome window closed before oracle finished. Please keep it open until completion.', {
-            cause: normalizedError,
-        });
+        await emitRuntimeHint();
+        throw new BrowserAutomationError('Chrome window closed before oracle finished. Please keep it open until completion.', {
+            stage: 'connection-lost',
+            runtime: {
+                chromePid: chrome.pid,
+                chromePort: chrome.port,
+                chromeHost,
+                userDataDir,
+                chromeTargetId: lastTargetId,
+                tabUrl: lastUrl,
+                controllerPid: process.pid,
+            },
+        }, normalizedError);
     }
     finally {
         try {
@@ -256,7 +363,7 @@ export async function runBrowserMode(options) {
             // ignore
         }
         removeTerminationHooks?.();
-        if (!config.keepBrowser) {
+        if (!effectiveKeepBrowser) {
             if (!connectionClosedUnexpectedly) {
                 try {
                     await chrome.kill();
@@ -276,6 +383,91 @@ export async function runBrowserMode(options) {
         }
     }
 }
+async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, }) {
+    if (!manualLogin) {
+        await ensureLoggedIn(runtime, logger, { appliedCookies });
+        return;
+    }
+    const deadline = Date.now() + Math.min(timeoutMs ?? 1_200_000, 20 * 60_000);
+    let lastNotice = 0;
+    while (Date.now() < deadline) {
+        try {
+            await ensureLoggedIn(runtime, logger, { appliedCookies });
+            return;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const loginDetected = message?.toLowerCase().includes('login button');
+            const sessionMissing = message?.toLowerCase().includes('session not detected');
+            if (!loginDetected && !sessionMissing) {
+                throw error;
+            }
+            const now = Date.now();
+            if (now - lastNotice > 5000) {
+                logger('Manual login mode: please sign into chatgpt.com in the opened Chrome window; waiting for session to appear...');
+                lastNotice = now;
+            }
+            await delay(1000);
+        }
+    }
+    throw new Error('Manual login mode timed out waiting for ChatGPT session; please sign in and retry.');
+}
+async function maybeReuseRunningChrome(userDataDir, logger) {
+    const port = await readDevToolsPort(userDataDir);
+    if (!port)
+        return null;
+    const versionUrl = `http://127.0.0.1:${port}/json/version`;
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 1500);
+        const response = await fetch(versionUrl, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        const pidPath = path.join(userDataDir, 'chrome.pid');
+        let pid;
+        try {
+            const rawPid = (await readFile(pidPath, 'utf8')).trim();
+            pid = Number.parseInt(rawPid, 10);
+            if (Number.isNaN(pid))
+                pid = undefined;
+        }
+        catch {
+            pid = undefined;
+        }
+        logger(`Found running Chrome for ${userDataDir}; reusing (DevTools port ${port}${pid ? `, pid ${pid}` : ''})`);
+        return {
+            port,
+            pid,
+            kill: async () => { },
+            process: undefined,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`DevToolsActivePort found for ${userDataDir} but unreachable (${message}); launching new Chrome.`);
+        return null;
+    }
+}
+async function readDevToolsPort(userDataDir) {
+    const candidates = [
+        path.join(userDataDir, 'DevToolsActivePort'),
+        path.join(userDataDir, 'Default', 'DevToolsActivePort'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const raw = await readFile(candidate, 'utf8');
+            const firstLine = raw.split(/\r?\n/u)[0]?.trim();
+            const port = Number.parseInt(firstLine ?? '', 10);
+            if (Number.isFinite(port)) {
+                return port;
+            }
+        }
+        catch {
+        }
+    }
+    return null;
+}
 async function runRemoteBrowserMode(promptText, attachments, config, logger, options) {
     const remoteChromeConfig = config.remoteChrome;
     if (!remoteChromeConfig) {
@@ -284,6 +476,26 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     const { host, port } = remoteChromeConfig;
     logger(`Connecting to remote Chrome at ${host}:${port}`);
     let client = null;
+    let remoteTargetId = null;
+    let lastUrl;
+    const runtimeHintCb = options.runtimeHintCb;
+    const emitRuntimeHint = async () => {
+        if (!runtimeHintCb)
+            return;
+        try {
+            await runtimeHintCb({
+                chromePort: port,
+                chromeHost: host,
+                chromeTargetId: remoteTargetId ?? undefined,
+                tabUrl: lastUrl,
+                controllerPid: process.pid,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger(`Failed to persist runtime hint: ${message}`);
+        }
+    };
     const startedAt = Date.now();
     let answerText = '';
     let answerMarkdown = '';
@@ -291,7 +503,10 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     let connectionClosedUnexpectedly = false;
     let stopThinkingMonitor = null;
     try {
-        client = await connectToRemoteChrome(host, port, logger);
+        const connection = await connectToRemoteChrome(host, port, logger, config.url);
+        client = connection.client;
+        remoteTargetId = connection.targetId ?? null;
+        await emitRuntimeHint();
         const markConnectionLost = () => {
             connectionClosedUnexpectedly = true;
         };
@@ -309,6 +524,19 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         await ensureLoggedIn(Runtime, logger, { remoteSession: true });
         await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
+        try {
+            const { result } = await Runtime.evaluate({
+                expression: 'location.href',
+                returnByValue: true,
+            });
+            if (typeof result?.value === 'string') {
+                lastUrl = result.value;
+            }
+            await emitRuntimeHint();
+        }
+        catch {
+            // ignore
+        }
         if (config.desiredModel) {
             await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger), {
                 retries: 2,
@@ -369,7 +597,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             answerChars,
             chromePid: undefined,
             chromePort: port,
+            chromeHost: host,
             userDataDir: undefined,
+            chromeTargetId: remoteTargetId ?? undefined,
+            tabUrl: lastUrl,
+            controllerPid: process.pid,
         };
     }
     catch (error) {
@@ -384,8 +616,15 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
             throw normalizedError;
         }
-        throw new Error('Remote Chrome connection lost before Oracle finished.', {
-            cause: normalizedError,
+        throw new BrowserAutomationError('Remote Chrome connection lost before Oracle finished.', {
+            stage: 'connection-lost',
+            runtime: {
+                chromeHost: host,
+                chromePort: port,
+                chromeTargetId: remoteTargetId ?? undefined,
+                tabUrl: lastUrl,
+                controllerPid: process.pid,
+            },
         });
     }
     finally {
@@ -397,6 +636,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         catch {
             // ignore
         }
+        await closeRemoteChromeTarget(host, port, remoteTargetId ?? undefined, logger);
         // Don't kill remote Chrome - it's not ours to manage
         const totalSeconds = (Date.now() - startedAt) / 1000;
         logger(`Remote session complete • ${totalSeconds.toFixed(1)}s total`);
@@ -429,7 +669,7 @@ function startThinkingStatusMonitor(Runtime, logger, includeDiagnostics = false)
     let lastMessage = null;
     const startedAt = Date.now();
     const interval = setInterval(async () => {
-        // biome-ignore lint/nursery/noUnnecessaryConditions: stop flag flips asynchronously
+        // stop flag flips asynchronously
         if (stopped || pending) {
             return;
         }
@@ -460,7 +700,7 @@ function startThinkingStatusMonitor(Runtime, logger, includeDiagnostics = false)
     }, 1500);
     interval.unref?.();
     return () => {
-        // biome-ignore lint/nursery/noUnnecessaryConditions: multiple callers may race to stop
+        // multiple callers may race to stop
         if (stopped) {
             return;
         }
@@ -491,6 +731,46 @@ function sanitizeThinkingText(raw) {
     }
     return trimmed;
 }
+function describeDevtoolsFirewallHint(host, port) {
+    if (!isWsl())
+        return null;
+    return [
+        `DevTools port ${host}:${port} is blocked from WSL.`,
+        '',
+        'PowerShell (admin):',
+        `New-NetFirewallRule -DisplayName 'Chrome DevTools ${port}' -Direction Inbound -Action Allow -Protocol TCP -LocalPort ${port}`,
+        "New-NetFirewallRule -DisplayName 'Chrome DevTools (chrome.exe)' -Direction Inbound -Action Allow -Program 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe' -Protocol TCP",
+        '',
+        'Re-run the same oracle command after adding the rule.',
+    ].join('\n');
+}
+function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    if (process.env.WSL_DISTRO_NAME)
+        return true;
+    return os.release().toLowerCase().includes('microsoft');
+}
+async function resolveUserDataBaseDir() {
+    // On WSL, Chrome launched via Windows can choke on UNC paths; prefer a Windows-backed temp folder.
+    if (isWsl()) {
+        const candidates = [
+            '/mnt/c/Users/Public/AppData/Local/Temp',
+            '/mnt/c/Temp',
+            '/mnt/c/Windows/Temp',
+        ];
+        for (const candidate of candidates) {
+            try {
+                await mkdir(candidate, { recursive: true });
+                return candidate;
+            }
+            catch {
+                // try next
+            }
+        }
+    }
+    return os.tmpdir();
+}
 function buildThinkingStatusExpression() {
     const selectors = [
         'span.loading-shimmer',

package/dist/src/browser/prompt.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { readFiles, createFileSections, MODEL_CONFIGS, TOKENIZER_OPTIONS, formatFileSection, } from '../oracle.js';
+import { isKnownModel } from '../oracle/modelResolver.js';
 import { buildPromptMarkdown } from '../oracle/promptAssembly.js';
 import { buildAttachmentPlan } from './policies.js';
 export async function assembleBrowserPrompt(runOptions, deps = {}) {
@@ -48,7 +49,8 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         });
     }
     const inlineFileCount = attachmentPlan.inlineFileCount;
-    const tokenizer = MODEL_CONFIGS[runOptions.model].tokenizer;
+    const modelConfig = isKnownModel(runOptions.model) ? MODEL_CONFIGS[runOptions.model] : MODEL_CONFIGS['gpt-5.1'];
+    const tokenizer = modelConfig.tokenizer;
     const tokenizerUserContent = inlineFileCount > 0 && attachmentPlan.inlineBlock
         ? [userPrompt, attachmentPlan.inlineBlock].filter((value) => Boolean(value?.trim())).join('\n\n').trim()
         : userPrompt;

package/dist/src/browser/reattach.js

@@ -0,0 +1,59 @@
+import CDP from 'chrome-remote-interface';
+import { waitForAssistantResponse, captureAssistantMarkdown } from './pageActions.js';
+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 async function resumeBrowserSession(runtime, config, logger, deps = {}) {
+    if (!runtime.chromePort) {
+        throw new Error('Missing chromePort; cannot reattach.');
+    }
+    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;
+    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 };
+}

package/dist/src/browser/sessionRunner.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { formatElapsed } from '../oracle.js';
+import { formatTokenCount } from '../oracle/runUtils.js';
 import { runBrowserMode } from '../browserMode.js';
 import { assembleBrowserPrompt } from './prompt.js';
 import { BrowserAutomationError } from '../oracle/errors.js';
@@ -46,6 +47,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (runOptions.verbose) {
         log(chalk.dim('Chrome automation does not stream output; this may take a minute...'));
     }
+    const persistRuntimeHint = deps.persistRuntimeHint ?? (() => { });
     let browserResult;
     try {
         browserResult = await executeBrowser({
@@ -55,6 +57,9 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             log: automationLogger,
             heartbeatIntervalMs: runOptions.heartbeatIntervalMs,
             verbose: runOptions.verbose,
+            runtimeHintCb: async (runtime) => {
+                await persistRuntimeHint({ ...runtime, controllerPid: runtime.controllerPid ?? process.pid });
+            },
         });
     }
     catch (error) {
@@ -76,7 +81,14 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         reasoningTokens: 0,
         totalTokens: promptArtifacts.estimatedInputTokens + browserResult.answerTokens,
     };
-    const tokensDisplay = `${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens}`;
+    const tokensDisplay = [
+        usage.inputTokens,
+        usage.outputTokens,
+        usage.reasoningTokens,
+        usage.totalTokens,
+    ]
+        .map((value) => formatTokenCount(value))
+        .join('/');
     const tokensLabel = runOptions.verbose ? 'tokens (input/output/reasoning/total)' : 'tok(i/o/r/t)';
     const statsParts = [`${runOptions.model}[browser]`, `${tokensLabel}=${tokensDisplay}`];
     if (runOptions.file && runOptions.file.length > 0) {
@@ -89,7 +101,9 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         runtime: {
             chromePid: browserResult.chromePid,
             chromePort: browserResult.chromePort,
+            chromeHost: browserResult.chromeHost,
             userDataDir: browserResult.userDataDir,
+            controllerPid: browserResult.controllerPid ?? process.pid,
         },
         answerText,
     };

package/dist/src/browser/windowsCookies.js

@@ -65,7 +65,8 @@ export async function loadWindowsCookies(dbPath, filterNames) {
 }
 function decryptCookie(value, aesKey) {
     const prefix = value.slice(0, 3).toString();
-    if (prefix === 'v10' || prefix === 'v11') {
+    // Chrome prefixes AES-GCM encrypted cookies with version markers like v10/v11/v20; treat all v** the same.
+    if (/^v\d{2}$/u.test(prefix)) {
         const iv = value.slice(3, 15);
         const tag = value.slice(value.length - 16);
         const data = value.slice(15, value.length - 16);

package/dist/src/cli/browserConfig.js

@@ -35,6 +35,7 @@ export async function buildBrowserConfig(options) {
         chromePath: options.browserChromePath ?? null,
         chromeCookiePath: options.browserCookiePath ?? null,
         url,
+        debugPort: selectBrowserPort(options),
         timeoutMs: options.browserTimeout ? parseDuration(options.browserTimeout, DEFAULT_BROWSER_TIMEOUT_MS) : undefined,
         inputTimeoutMs: options.browserInputTimeout
             ? parseDuration(options.browserInputTimeout, DEFAULT_BROWSER_INPUT_TIMEOUT_MS)
@@ -45,6 +46,7 @@ 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,
         hideWindow: options.browserHideWindow ? true : undefined,
         desiredModel: shouldUseOverride ? desiredModelOverride : mapModelToBrowserLabel(options.model),
         debug: options.verbose ? true : undefined,
@@ -53,6 +55,15 @@ export async function buildBrowserConfig(options) {
         remoteChrome,
     };
 }
+function selectBrowserPort(options) {
+    const candidate = options.browserPort ?? options.browserDebugPort;
+    if (candidate === undefined || candidate === null)
+        return null;
+    if (!Number.isFinite(candidate) || candidate <= 0 || candidate > 65_535) {
+        throw new Error(`Invalid browser port: ${candidate}. Expected a number between 1 and 65535.`);
+    }
+    return candidate;
+}
 export function mapModelToBrowserLabel(model) {
     return BROWSER_MODEL_LABELS[model] ?? DEFAULT_MODEL_TARGET;
 }