@steipete/oracle 0.4.5 → 0.5.0

package/dist/src/browser/chromeLifecycle.js

@@ -1,19 +1,36 @@
 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 } from 'chrome-launcher';
+import { launch, Launcher } from 'chrome-launcher';
 const execFileAsync = promisify(execFile);
 export async function launchChrome(config, userDataDir, logger) {
-    const chromeFlags = buildChromeFlags(config.headless);
-    const launcher = await launch({
-        chromePath: config.chromePath ?? undefined,
-        chromeFlags,
-        userDataDir,
-    });
+    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,
+            port: debugPort ?? undefined,
+        });
     const pidLabel = typeof launcher.pid === 'number' ? ` (pid ${launcher.pid})` : '';
-    logger(`Launched Chrome${pidLabel} on port ${launcher.port}`);
-    return launcher;
+    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) {
     const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
@@ -23,15 +40,20 @@ export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logge
             return;
         }
         handling = true;
-        logger(`Received ${signal}; terminating Chrome process`);
+        if (keepBrowser) {
+            logger(`Received ${signal}; leaving Chrome running for potential reattach`);
+        }
+        else {
+            logger(`Received ${signal}; terminating Chrome process`);
+        }
         void (async () => {
-            try {
-                await chrome.kill();
-            }
-            catch {
-                // ignore kill failures
-            }
             if (!keepBrowser) {
+                try {
+                    await chrome.kill();
+                }
+                catch {
+                    // ignore kill failures
+                }
                 await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
             }
         })().finally(() => {
@@ -71,17 +93,44 @@ export async function hideChromeWindow(chrome, logger) {
         logger(`Failed to hide Chrome window: ${message}`);
     }
 }
-export async function connectToChrome(port, logger) {
-    const client = await CDP({ port });
+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) {
-    const client = await CDP({ host, port });
+export async function connectToRemoteChrome(host, port, logger, targetUrl) {
+    if (targetUrl) {
+        try {
+            const target = await CDP.New({ host, port, url: targetUrl });
+            const client = await CDP({ host, port, target: target.id });
+            logger(`Opened dedicated remote Chrome tab targeting ${targetUrl}`);
+            return { client, targetId: target.id };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger(`Failed to open dedicated remote Chrome tab (${message}); falling back to first target.`);
+        }
+    }
+    const fallbackClient = await CDP({ host, port });
     logger(`Connected to remote Chrome DevTools protocol at ${host}:${port}`);
-    return client;
+    return { client: fallbackClient };
 }
-function buildChromeFlags(_headless) {
+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}`);
+    }
+}
+function buildChromeFlags(headless, debugBindAddress) {
     const flags = [
         '--disable-background-networking',
         '--disable-background-timer-throttling',
@@ -99,9 +148,101 @@ function buildChromeFlags(_headless) {
         '--disable-features=TranslateUI,AutomationControlled',
         '--mute-audio',
         '--window-size=1280,720',
-        '--password-store=basic',
-        '--use-mock-keychain',
     ];
-    // Headless/new is blocked by Cloudflare; always run headful.
+    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,
+        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

@@ -1,5 +1,7 @@
 import { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
 import { normalizeChatgptUrl } from './utils.js';
+import os from 'node:os';
+import path from 'node:path';
 export const DEFAULT_BROWSER_CONFIG = {
     chromeProfile: null,
     chromePath: null,
@@ -7,6 +9,7 @@ export const DEFAULT_BROWSER_CONFIG = {
     url: CHATGPT_URL,
     chatgptUrl: CHATGPT_URL,
     timeoutMs: 1_200_000,
+    debugPort: null,
     inputTimeoutMs: 30_000,
     cookieSync: true,
     cookieNames: null,
@@ -19,20 +22,30 @@ export const DEFAULT_BROWSER_CONFIG = {
     debug: false,
     allowCookieErrors: false,
     remoteChrome: null,
+    manualLogin: false,
+    manualLoginProfileDir: null,
 };
 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 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,
-        cookieSync: config?.cookieSync ?? DEFAULT_BROWSER_CONFIG.cookieSync,
+        cookieSync: config?.cookieSync ?? cookieSyncDefault,
         cookieNames: config?.cookieNames ?? DEFAULT_BROWSER_CONFIG.cookieNames,
         inlineCookies: config?.inlineCookies ?? DEFAULT_BROWSER_CONFIG.inlineCookies,
         inlineCookiesSource: config?.inlineCookiesSource ?? DEFAULT_BROWSER_CONFIG.inlineCookiesSource,
@@ -45,5 +58,16 @@ export function resolveBrowserConfig(config) {
         chromeCookiePath: config?.chromeCookiePath ?? DEFAULT_BROWSER_CONFIG.chromeCookiePath,
         debug: config?.debug ?? DEFAULT_BROWSER_CONFIG.debug,
         allowCookieErrors: config?.allowCookieErrors ?? envAllowCookieErrors ?? DEFAULT_BROWSER_CONFIG.allowCookieErrors,
+        manualLogin,
+        manualLoginProfileDir: manualLogin ? resolvedProfileDir : null,
     };
 }
+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;
+}

package/dist/src/browser/constants.js

@@ -24,18 +24,37 @@ export const CLOUDFLARE_SCRIPT_SELECTOR = 'script[src*="/challenge-platform/"]';
 export const CLOUDFLARE_TITLE = 'just a moment';
 export const PROMPT_PRIMARY_SELECTOR = '#prompt-textarea';
 export const PROMPT_FALLBACK_SELECTOR = 'textarea[name="prompt-textarea"]';
-export const FILE_INPUT_SELECTOR = 'form input[type="file"]:not([accept])';
-export const GENERIC_FILE_INPUT_SELECTOR = 'input[type="file"]:not([accept])';
+export const FILE_INPUT_SELECTORS = [
+    'form input[type="file"]:not([accept])',
+    'input[type="file"][multiple]:not([accept])',
+    'input[type="file"][multiple]',
+    'input[type="file"]:not([accept])',
+    'input[type="file"][data-testid*="file"]',
+];
+// Legacy single selectors kept for compatibility with older call-sites
+export const FILE_INPUT_SELECTOR = FILE_INPUT_SELECTORS[0];
+export const GENERIC_FILE_INPUT_SELECTOR = FILE_INPUT_SELECTORS[3];
 export const MENU_CONTAINER_SELECTOR = '[role="menu"], [data-radix-collection-root]';
 export const MENU_ITEM_SELECTOR = 'button, [role="menuitem"], [role="menuitemradio"], [data-testid*="model-switcher-"]';
 export const UPLOAD_STATUS_SELECTORS = [
     '[data-testid*="upload"]',
     '[data-testid*="attachment"]',
+    '[data-testid*="progress"]',
     '[data-state="loading"]',
+    '[data-state="uploading"]',
+    '[data-state="pending"]',
     '[aria-live="polite"]',
+    '[aria-live="assertive"]',
 ];
 export const STOP_BUTTON_SELECTOR = '[data-testid="stop-button"]';
-export const SEND_BUTTON_SELECTOR = '[data-testid="send-button"]';
+export const SEND_BUTTON_SELECTORS = [
+    '[data-testid="send-button"]',
+    'button[data-testid="composer-send-button"]',
+    'button[aria-label="Send message"]',
+    'button[aria-label*="Send"]',
+    'button[type="submit"][data-testid*="send"]',
+];
+export const SEND_BUTTON_SELECTOR = SEND_BUTTON_SELECTORS[0];
 export const MODEL_BUTTON_SELECTOR = '[data-testid="model-switcher-dropdown-button"]';
 export const COPY_BUTTON_SELECTOR = 'button[data-testid="copy-turn-action-button"]';
 // Action buttons that only appear once a turn has finished rendering.