@steipete/oracle 0.4.5 → 0.5.1

package/dist/src/browser/index.js

@@ -1,14 +1,16 @@
-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 net from 'node:net';
 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) {
@@ -17,7 +19,7 @@ export async function runBrowserMode(options) {
         throw new Error('Prompt text is required when using browser mode.');
     }
     const attachments = options.attachments ?? [];
-    const config = resolveBrowserConfig(options.config);
+    let config = resolveBrowserConfig(options.config);
     const logger = options.log ?? ((_message) => { });
     if (logger.verbose === undefined) {
         logger.verbose = Boolean(config.debug);
@@ -25,12 +27,44 @@ 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,
             promptLength: promptText.length,
         })}`);
     }
+    if (!config.remoteChrome && !config.manualLogin) {
+        const preferredPort = config.debugPort ?? DEFAULT_DEBUG_PORT;
+        const availablePort = await pickAvailableDebugPort(preferredPort, logger);
+        if (availablePort !== preferredPort) {
+            logger(`DevTools port ${preferredPort} busy; using ${availablePort} to avoid attaching to stray Chrome.`);
+        }
+        config = { ...config, debugPort: availablePort };
+    }
     // Remote Chrome mode - connect to existing browser
     if (config.remoteChrome) {
         // Warn about ignored local-only options
@@ -40,12 +74,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 +113,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 +140,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 +170,68 @@ 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)');
+        }
+        if (cookieSyncEnabled && !manualLogin && (appliedCookies ?? 0) === 0 && !config.inlineCookies) {
+            throw new BrowserAutomationError('No ChatGPT cookies were applied from your Chrome profile; cannot proceed in browser mode. ' +
+                'Make sure ChatGPT is signed in in the selected profile or rebuild the keytar native module if it failed to load.', {
+                stage: 'execute-browser',
+                details: {
+                    profile: config.chromeProfile ?? 'Default',
+                    cookiePath: config.chromeCookiePath ?? null,
+                    hint: 'Rebuild keytar: PYTHON=/usr/bin/python3 /Users/steipete/Projects/oracle/runner npx node-gyp rebuild (run inside the keytar path from the error), then retry.',
+                },
+            });
         }
         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 +336,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 +359,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 +383,7 @@ export async function runBrowserMode(options) {
             // ignore
         }
         removeTerminationHooks?.();
-        if (!config.keepBrowser) {
+        if (!effectiveKeepBrowser) {
             if (!connectionClosedUnexpectedly) {
                 try {
                     await chrome.kill();
@@ -276,6 +403,153 @@ export async function runBrowserMode(options) {
         }
     }
 }
+const DEFAULT_DEBUG_PORT = 9222;
+async function pickAvailableDebugPort(preferredPort, logger) {
+    const start = Number.isFinite(preferredPort) && preferredPort > 0 ? preferredPort : DEFAULT_DEBUG_PORT;
+    for (let offset = 0; offset < 10; offset++) {
+        const candidate = start + offset;
+        if (await isPortAvailable(candidate)) {
+            return candidate;
+        }
+    }
+    const fallback = await findEphemeralPort();
+    logger(`DevTools ports ${start}-${start + 9} are occupied; falling back to ${fallback}.`);
+    return fallback;
+}
+async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', () => resolve(false));
+        server.once('listening', () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+async function findEphemeralPort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once('error', (error) => {
+            server.close();
+            reject(error);
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (address && typeof address === 'object') {
+                const port = address.port;
+                server.close(() => resolve(port));
+            }
+            else {
+                server.close(() => reject(new Error('Failed to acquire ephemeral port')));
+            }
+        });
+    });
+}
+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 _assertNavigatedToHttp(runtime, _logger, timeoutMs = 10_000) {
+    const deadline = Date.now() + timeoutMs;
+    let lastUrl = '';
+    while (Date.now() < deadline) {
+        const { result } = await runtime.evaluate({
+            expression: 'typeof location === "object" && location.href ? location.href : ""',
+            returnByValue: true,
+        });
+        const url = typeof result?.value === 'string' ? result.value : '';
+        lastUrl = url;
+        if (/^https?:\/\//i.test(url)) {
+            return url;
+        }
+        await delay(250);
+    }
+    throw new BrowserAutomationError('ChatGPT session not detected; page never left new tab.', {
+        stage: 'execute-browser',
+        details: { url: lastUrl || '(empty)' },
+    });
+}
+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 +558,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 +585,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 +606,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 +679,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 +698,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 +718,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 +751,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 +782,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 +813,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',