@steipete/oracle 0.8.4 → 0.8.6

package/dist/src/browser/chromeLifecycle.js

@@ -7,6 +7,7 @@ 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();
@@ -124,15 +125,14 @@ export async function connectToChrome(port, logger, host) {
 }
 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 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 });
@@ -154,6 +154,75 @@ export async function closeRemoteChromeTarget(host, port, targetId, logger) {
         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',

package/dist/src/browser/config.js

@@ -12,6 +12,13 @@ export const DEFAULT_BROWSER_CONFIG = {
     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,
@@ -57,6 +64,13 @@ export function resolveBrowserConfig(config) {
         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,

package/dist/src/browser/detect.js

@@ -0,0 +1,164 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Launcher } from 'chrome-launcher';
+export async function detectChromeBinary() {
+    const envPath = (process.env.CHROME_PATH ?? '').trim();
+    if (envPath) {
+        const ok = await isExecutable(envPath);
+        if (ok) {
+            return { path: envPath };
+        }
+    }
+    const launcherDetected = Launcher.getFirstInstallation();
+    if (launcherDetected) {
+        return { path: launcherDetected };
+    }
+    const candidates = platformChromeCandidates();
+    for (const candidate of candidates.absolutePaths) {
+        if (await isExecutable(candidate)) {
+            return { path: candidate };
+        }
+    }
+    const fromPath = await findOnPath(candidates.binaryNames);
+    if (fromPath) {
+        return { path: fromPath };
+    }
+    return { path: null };
+}
+export async function detectChromeCookieDb({ profile }) {
+    const profileName = profile?.trim() ? profile.trim() : 'Default';
+    if (process.platform === 'win32') {
+        return null;
+    }
+    const roots = platformProfileRoots();
+    for (const root of roots) {
+        const dir = path.join(root, profileName);
+        const direct = path.join(dir, 'Cookies');
+        if (await isFile(direct))
+            return direct;
+        const network = path.join(dir, 'Network', 'Cookies');
+        if (await isFile(network))
+            return network;
+    }
+    return null;
+}
+function platformChromeCandidates() {
+    if (process.platform === 'linux') {
+        return {
+            binaryNames: [
+                'google-chrome',
+                'google-chrome-stable',
+                'chromium',
+                'chromium-browser',
+                'brave-browser',
+                'microsoft-edge',
+                'microsoft-edge-stable',
+            ],
+            absolutePaths: [
+                '/usr/bin/google-chrome',
+                '/usr/bin/google-chrome-stable',
+                '/usr/bin/google-chrome-beta',
+                '/usr/bin/google-chrome-unstable',
+                '/usr/bin/chromium',
+                '/usr/bin/chromium-browser',
+                '/usr/bin/brave-browser',
+                '/usr/bin/microsoft-edge',
+                '/usr/bin/microsoft-edge-stable',
+                '/snap/bin/chromium',
+                '/snap/bin/brave',
+                '/snap/bin/brave-browser',
+                '/snap/bin/microsoft-edge',
+                '/opt/google/chrome/chrome',
+            ],
+        };
+    }
+    if (process.platform === 'darwin') {
+        return {
+            binaryNames: [],
+            absolutePaths: [
+                '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+                '/Applications/Chromium.app/Contents/MacOS/Chromium',
+                '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+                '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+            ],
+        };
+    }
+    if (process.platform === 'win32') {
+        const programFiles = process.env.ProgramFiles ?? 'C:\\Program Files';
+        const programFilesX86 = process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)';
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+        return {
+            binaryNames: [],
+            absolutePaths: [
+                path.join(programFiles, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+                path.join(programFilesX86, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+                path.join(localAppData, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+                path.join(programFiles, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+                path.join(programFilesX86, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+            ],
+        };
+    }
+    return { binaryNames: [], absolutePaths: [] };
+}
+function platformProfileRoots() {
+    const home = os.homedir();
+    if (process.platform === 'darwin') {
+        return [
+            path.join(home, 'Library', 'Application Support', 'Google', 'Chrome'),
+            path.join(home, 'Library', 'Application Support', 'Chromium'),
+            path.join(home, 'Library', 'Application Support', 'Microsoft Edge'),
+            path.join(home, 'Library', 'Application Support', 'BraveSoftware', 'Brave-Browser'),
+        ];
+    }
+    if (process.platform === 'linux') {
+        return [
+            path.join(home, '.config', 'google-chrome'),
+            path.join(home, '.config', 'google-chrome-beta'),
+            path.join(home, '.config', 'google-chrome-unstable'),
+            path.join(home, '.config', 'chromium'),
+            path.join(home, '.config', 'microsoft-edge'),
+            path.join(home, '.config', 'BraveSoftware', 'Brave-Browser'),
+            // Snap Chromium profiles
+            path.join(home, 'snap', 'chromium', 'common', 'chromium'),
+            path.join(home, 'snap', 'chromium', 'current', 'chromium'),
+        ];
+    }
+    return [];
+}
+async function isExecutable(candidate) {
+    try {
+        const stat = await fs.stat(candidate);
+        if (!stat.isFile())
+            return false;
+        if (process.platform === 'win32')
+            return true;
+        // eslint-disable-next-line no-bitwise
+        return (stat.mode & 0o111) !== 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function isFile(candidate) {
+    try {
+        const stat = await fs.stat(candidate);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function findOnPath(names) {
+    const rawPath = process.env.PATH ?? '';
+    const dirs = rawPath.split(path.delimiter).filter(Boolean);
+    for (const name of names) {
+        for (const dir of dirs) {
+            const candidate = path.join(dir, name);
+            if (await isExecutable(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}