@steipete/oracle 0.4.0

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

@@ -0,0 +1,154 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { FILE_INPUT_SELECTOR, GENERIC_FILE_INPUT_SELECTOR } from '../constants.js';
+import { delay } from '../utils.js';
+import { logDomFailure } from '../domDebug.js';
+/**
+ * Upload file to remote Chrome by transferring content via CDP
+ * Used when browser is on a different machine than CLI
+ */
+export async function uploadAttachmentViaDataTransfer(deps, attachment, logger) {
+    const { runtime, dom } = deps;
+    if (!dom) {
+        throw new Error('DOM domain unavailable while uploading attachments.');
+    }
+    // Read file content from local filesystem
+    const fileContent = await readFile(attachment.path);
+    // Enforce file size limit to avoid CDP protocol issues
+    const MAX_BYTES = 20 * 1024 * 1024; // 20MB limit for CDP transfer
+    if (fileContent.length > MAX_BYTES) {
+        throw new Error(`Attachment ${path.basename(attachment.path)} is too large for remote upload (${fileContent.length} bytes). Maximum size is ${MAX_BYTES} bytes.`);
+    }
+    const base64Content = fileContent.toString('base64');
+    const fileName = path.basename(attachment.path);
+    const mimeType = guessMimeType(fileName);
+    logger(`Transferring ${fileName} (${fileContent.length} bytes) to remote browser...`);
+    // Find file input element
+    const documentNode = await dom.getDocument();
+    const selectors = [FILE_INPUT_SELECTOR, GENERIC_FILE_INPUT_SELECTOR];
+    let fileInputSelector;
+    for (const selector of selectors) {
+        const result = await dom.querySelector({ nodeId: documentNode.root.nodeId, selector });
+        if (result.nodeId) {
+            fileInputSelector = selector;
+            break;
+        }
+    }
+    if (!fileInputSelector) {
+        await logDomFailure(runtime, logger, 'file-input');
+        throw new Error('Unable to locate ChatGPT file attachment input.');
+    }
+    // Inject file via JavaScript DataTransfer API
+    const expression = `
+    (function() {
+      // Check for required file APIs
+      if (!('File' in window) || !('Blob' in window) || !('DataTransfer' in window) || typeof atob !== 'function') {
+        return { success: false, error: 'Required file APIs are not available in this browser' };
+      }
+
+      const fileInput = document.querySelector(${JSON.stringify(fileInputSelector)});
+      if (!fileInput) {
+        return { success: false, error: 'File input not found' };
+      }
+
+      // Validate that the element is actually a file input
+      if (!(fileInput instanceof HTMLInputElement) || fileInput.type !== 'file') {
+        return { success: false, error: 'Found element is not a file input' };
+      }
+
+      // Convert base64 to Blob
+      const base64Data = ${JSON.stringify(base64Content)};
+      const binaryString = atob(base64Data);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      const blob = new Blob([bytes], { type: ${JSON.stringify(mimeType)} });
+
+      // Create File object
+      const file = new File([blob], ${JSON.stringify(fileName)}, {
+        type: ${JSON.stringify(mimeType)},
+        lastModified: Date.now()
+      });
+
+      // Create DataTransfer and assign to input
+      const dataTransfer = new DataTransfer();
+      dataTransfer.items.add(file);
+      fileInput.files = dataTransfer.files;
+
+      // Trigger both input and change events for better compatibility
+      fileInput.dispatchEvent(new Event('input', { bubbles: true }));
+      fileInput.dispatchEvent(new Event('change', { bubbles: true }));
+
+      return { success: true, fileName: file.name, size: file.size };
+    })()
+  `;
+    const evalResult = await runtime.evaluate({ expression, returnByValue: true });
+    // Check for JavaScript exceptions during evaluation
+    if (evalResult.exceptionDetails) {
+        const description = evalResult.exceptionDetails.text ?? 'JS evaluation failed';
+        throw new Error(`Failed to transfer file to remote browser: ${description}`);
+    }
+    // Validate result structure before accessing
+    if (!evalResult.result || typeof evalResult.result.value !== 'object' || evalResult.result.value == null) {
+        throw new Error('Failed to transfer file to remote browser: unexpected evaluation result');
+    }
+    const uploadResult = evalResult.result.value;
+    if (!uploadResult.success) {
+        throw new Error(`Failed to transfer file to remote browser: ${uploadResult.error || 'Unknown error'}`);
+    }
+    logger(`File transferred: ${uploadResult.fileName} (${uploadResult.size} bytes)`);
+    // Give ChatGPT a moment to process the file
+    await delay(500);
+    logger('Attachment queued');
+}
+function guessMimeType(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    const mimeTypes = {
+        // Text files
+        '.txt': 'text/plain',
+        '.md': 'text/markdown',
+        '.csv': 'text/csv',
+        // Code files
+        '.json': 'application/json',
+        '.js': 'text/javascript',
+        '.ts': 'text/typescript',
+        '.jsx': 'text/javascript',
+        '.tsx': 'text/typescript',
+        '.py': 'text/x-python',
+        '.java': 'text/x-java',
+        '.c': 'text/x-c',
+        '.cpp': 'text/x-c++',
+        '.h': 'text/x-c',
+        '.hpp': 'text/x-c++',
+        '.sh': 'text/x-sh',
+        '.bash': 'text/x-sh',
+        // Web files
+        '.html': 'text/html',
+        '.css': 'text/css',
+        '.xml': 'text/xml',
+        '.yaml': 'text/yaml',
+        '.yml': 'text/yaml',
+        // Documents
+        '.pdf': 'application/pdf',
+        '.doc': 'application/msword',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.xls': 'application/vnd.ms-excel',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.ppt': 'application/vnd.ms-powerpoint',
+        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        // Images
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.webp': 'image/webp',
+        // Archives
+        '.zip': 'application/zip',
+        '.tar': 'application/x-tar',
+        '.gz': 'application/gzip',
+        '.7z': 'application/x-7z-compressed',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}

package/dist/src/browser/chromeCookies.js

@@ -0,0 +1,274 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import chromeCookies from 'chrome-cookies-secure';
+import { COOKIE_URLS } from './constants.js';
+import './keytarShim.js';
+import { ensureCookiesDirForFallback } from './windowsCookies.js';
+const COOKIE_READ_TIMEOUT_MS = readDuration('ORACLE_COOKIE_LOAD_TIMEOUT_MS', 5_000);
+const KEYCHAIN_PROBE_TIMEOUT_MS = readDuration('ORACLE_KEYCHAIN_PROBE_TIMEOUT_MS', 3_000);
+const MAC_KEYCHAIN_LABELS = loadKeychainLabels();
+export async function loadChromeCookies({ targetUrl, profile, explicitCookiePath, filterNames, }) {
+    const urlsToCheck = Array.from(new Set([stripQuery(targetUrl), ...COOKIE_URLS]));
+    const merged = new Map();
+    const cookieFile = await resolveCookieFilePath({ explicitPath: explicitCookiePath, profile });
+    const cookiesPath = await materializeCookieFile(cookieFile); // returns the copied file (or source on non-Windows)
+    const fallbackDir = await ensureCookiesDirForFallback(cookiesPath);
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] resolved cookie file: ${cookiesPath}`);
+        console.log(`[cookies] fallback dir for chrome-cookies-secure: ${fallbackDir}`);
+    }
+    await ensureMacKeychainReadable();
+    for (const url of urlsToCheck) {
+        let raw;
+        try {
+            const pathForSecure = await adaptPathForChromeCookies(fallbackDir);
+            raw = await settleWithTimeout(chromeCookies.getCookiesPromised(url, 'puppeteer', pathForSecure), COOKIE_READ_TIMEOUT_MS, `Timed out reading Chrome cookies from ${pathForSecure} (after ${COOKIE_READ_TIMEOUT_MS} ms)`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load Chrome cookies for ${url}: ${message}`);
+        }
+        if (!Array.isArray(raw))
+            continue;
+        const fallbackHost = new URL(url).hostname;
+        for (const cookie of raw) {
+            if (filterNames && filterNames.size > 0 && !filterNames.has(cookie.name))
+                continue;
+            const normalized = normalizeCookie(cookie, fallbackHost);
+            if (!normalized)
+                continue;
+            const key = `${normalized.domain ?? fallbackHost}:${normalized.name}`;
+            if (!merged.has(key)) {
+                merged.set(key, normalized);
+            }
+        }
+    }
+    return Array.from(merged.values());
+}
+async function ensureMacKeychainReadable() {
+    if (process.platform !== 'darwin') {
+        return;
+    }
+    // chrome-cookies-secure can hang forever when macOS Keychain rejects access (e.g., SSH/no GUI).
+    // Probe the keychain ourselves with a timeout so callers fail fast instead of blocking the run.
+    const keytarModule = await import('keytar');
+    const keytar = (keytarModule.default ?? keytarModule);
+    const password = await settleWithTimeout(findKeychainPassword(keytar, MAC_KEYCHAIN_LABELS), KEYCHAIN_PROBE_TIMEOUT_MS, `Timed out reading macOS Keychain while looking up Chrome Safe Storage (after ${KEYCHAIN_PROBE_TIMEOUT_MS} ms). Unlock the login keychain or start oracle serve from a GUI session.`);
+    if (!password) {
+        throw new Error('macOS Keychain denied access to Chrome cookies. Unlock the login keychain or run oracle serve from a GUI session, then retry.');
+    }
+}
+async function findKeychainPassword(keytar, labels) {
+    let lastError = null;
+    for (const label of labels) {
+        try {
+            const value = await keytar.getPassword(label.service, label.account);
+            if (value)
+                return value;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    if (lastError) {
+        throw lastError;
+    }
+    return null;
+}
+function settleWithTimeout(promise, timeoutMs, timeoutMessage) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
+        timer.unref?.();
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function normalizeCookie(cookie, fallbackHost) {
+    if (!cookie?.name)
+        return null;
+    const domain = cookie.domain?.startsWith('.') ? cookie.domain.slice(1) : cookie.domain ?? fallbackHost;
+    const expires = normalizeExpiration(cookie.expires);
+    const secure = typeof cookie.Secure === 'boolean' ? cookie.Secure : true;
+    const httpOnly = typeof cookie.HttpOnly === 'boolean' ? cookie.HttpOnly : false;
+    return {
+        name: cookie.name,
+        value: cleanValue(cookie.value ?? ''),
+        domain,
+        path: cookie.path ?? '/',
+        expires,
+        secure,
+        httpOnly,
+    };
+}
+function cleanValue(value) {
+    let i = 0;
+    while (i < value.length && value.charCodeAt(i) < 0x20)
+        i += 1;
+    return value.slice(i);
+}
+function normalizeExpiration(expires) {
+    if (!expires || Number.isNaN(expires)) {
+        return undefined;
+    }
+    const value = Number(expires);
+    if (value <= 0)
+        return undefined;
+    if (value > 1_000_000_000_000) {
+        return Math.round(value / 1_000_000 - 11644473600);
+    }
+    if (value > 1_000_000_000) {
+        return Math.round(value / 1000);
+    }
+    return Math.round(value);
+}
+async function resolveCookieFilePath({ explicitPath, profile, }) {
+    if (explicitPath && explicitPath.trim().length > 0) {
+        return ensureCookieFile(explicitPath);
+    }
+    if (profile && looksLikePath(profile)) {
+        return ensureCookieFile(profile);
+    }
+    const profileName = profile && profile.trim().length > 0 ? profile : 'Default';
+    const baseDir = await defaultProfileRoot();
+    return ensureCookieFile(path.join(baseDir, profileName));
+}
+async function adaptPathForChromeCookies(resolved) {
+    const stat = await fs.stat(resolved).catch(() => null);
+    if (stat?.isFile()) {
+        // chrome-cookies-secure appends "Cookies" when given a directory; if we already have the file, return its directory.
+        return path.dirname(resolved);
+    }
+    return resolved;
+}
+async function ensureCookieFile(inputPath) {
+    const expanded = expandPath(inputPath);
+    const stat = await fs.stat(expanded).catch(() => null);
+    if (!stat) {
+        throw new Error(`Unable to locate Chrome cookie DB at ${expanded}`);
+    }
+    if (stat.isDirectory()) {
+        const directFile = path.join(expanded, 'Cookies');
+        if (await fileExists(directFile))
+            return directFile;
+        const networkFile = path.join(expanded, 'Network', 'Cookies');
+        if (await fileExists(networkFile))
+            return networkFile;
+        throw new Error(`No Cookies DB found under ${expanded}`);
+    }
+    return expanded;
+}
+async function fileExists(candidate) {
+    try {
+        const stat = await fs.stat(candidate);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function expandPath(input) {
+    if (input.startsWith('~/')) {
+        return path.join(os.homedir(), input.slice(2));
+    }
+    return path.isAbsolute(input) ? input : path.resolve(process.cwd(), input);
+}
+function looksLikePath(value) {
+    return value.includes('/') || value.includes('\\');
+}
+async function materializeCookieFile(sourcePath) {
+    if (process.platform !== 'win32')
+        return sourcePath;
+    // Chrome can keep the Cookies DB locked; copy to a temp file so sqlite can open it reliably.
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-'));
+    const tempPath = path.join(tempDir, 'Cookies');
+    try {
+        await fs.copyFile(sourcePath, tempPath);
+        return tempPath;
+    }
+    catch (_error) {
+        // Fall back to the original path if the copy fails; upstream error handling will surface issues.
+        return sourcePath;
+    }
+}
+async function defaultProfileRoot() {
+    const candidates = [];
+    if (process.platform === 'darwin') {
+        candidates.push(path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome'), path.join(os.homedir(), 'Library', 'Application Support', 'Microsoft Edge'), path.join(os.homedir(), 'Library', 'Application Support', 'Chromium'));
+    }
+    else if (process.platform === 'linux') {
+        candidates.push(path.join(os.homedir(), '.config', 'google-chrome'), path.join(os.homedir(), '.config', 'microsoft-edge'), path.join(os.homedir(), '.config', 'chromium'), 
+        // Snap Chromium profiles
+        path.join(os.homedir(), 'snap', 'chromium', 'common', 'chromium'), path.join(os.homedir(), 'snap', 'chromium', 'current', 'chromium'));
+    }
+    else if (process.platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+        candidates.push(path.join(localAppData, 'Google', 'Chrome', 'User Data'), path.join(localAppData, 'Microsoft', 'Edge', 'User Data'), path.join(localAppData, 'Chromium', 'User Data'));
+    }
+    else {
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // fallback: first candidate even if missing; upstream will throw clearer error
+    return candidates[0];
+}
+function stripQuery(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.hash = '';
+        parsed.search = '';
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+}
+function readDuration(envKey, fallback) {
+    const raw = process.env[envKey];
+    if (!raw)
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function loadKeychainLabels() {
+    const defaults = [
+        { service: 'Chrome Safe Storage', account: 'Chrome' },
+        { service: 'Chromium Safe Storage', account: 'Chromium' },
+        { service: 'Microsoft Edge Safe Storage', account: 'Microsoft Edge' },
+        { service: 'Brave Safe Storage', account: 'Brave' },
+        { service: 'Vivaldi Safe Storage', account: 'Vivaldi' },
+    ];
+    const rawEnv = process.env.ORACLE_KEYCHAIN_LABELS;
+    if (!rawEnv)
+        return defaults;
+    try {
+        const parsed = JSON.parse(rawEnv);
+        if (!Array.isArray(parsed))
+            return defaults;
+        const envLabels = parsed
+            .map((entry) => (entry && typeof entry === 'object' ? entry : null))
+            .filter((entry) => Boolean(entry?.service && entry?.account));
+        return envLabels.length ? [...envLabels, ...defaults] : defaults;
+    }
+    catch {
+        return defaults;
+    }
+}
+// biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
+export const __test__ = {
+    normalizeExpiration,
+    cleanValue,
+    looksLikePath,
+    defaultProfileRoot,
+};

package/dist/src/browser/chromeLifecycle.js

@@ -0,0 +1,107 @@
+import { rm } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import CDP from 'chrome-remote-interface';
+import { launch } 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 pidLabel = typeof launcher.pid === 'number' ? ` (pid ${launcher.pid})` : '';
+    logger(`Launched Chrome${pidLabel} on port ${launcher.port}`);
+    return launcher;
+}
+export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logger) {
+    const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
+    let handling;
+    const handleSignal = (signal) => {
+        if (handling) {
+            return;
+        }
+        handling = true;
+        logger(`Received ${signal}; terminating Chrome process`);
+        void (async () => {
+            try {
+                await chrome.kill();
+            }
+            catch {
+                // ignore kill failures
+            }
+            if (!keepBrowser) {
+                await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+            }
+        })().finally(() => {
+            const exitCode = signal === 'SIGINT' ? 130 : 1;
+            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) {
+    const client = await CDP({ port });
+    logger('Connected to Chrome DevTools protocol');
+    return client;
+}
+export async function connectToRemoteChrome(host, port, logger) {
+    const client = await CDP({ host, port });
+    logger(`Connected to remote Chrome DevTools protocol at ${host}:${port}`);
+    return client;
+}
+function buildChromeFlags(_headless) {
+    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',
+        '--password-store=basic',
+        '--use-mock-keychain',
+    ];
+    // Headless/new is blocked by Cloudflare; always run headful.
+    return flags;
+}

package/dist/src/browser/config.js

@@ -0,0 +1,49 @@
+import { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
+import { normalizeChatgptUrl } from './utils.js';
+export const DEFAULT_BROWSER_CONFIG = {
+    chromeProfile: null,
+    chromePath: null,
+    chromeCookiePath: null,
+    url: CHATGPT_URL,
+    chatgptUrl: CHATGPT_URL,
+    timeoutMs: 1_200_000,
+    inputTimeoutMs: 30_000,
+    cookieSync: true,
+    cookieNames: null,
+    inlineCookies: null,
+    inlineCookiesSource: null,
+    headless: false,
+    keepBrowser: false,
+    hideWindow: false,
+    desiredModel: DEFAULT_MODEL_TARGET,
+    debug: false,
+    allowCookieErrors: false,
+    remoteChrome: null,
+};
+export function resolveBrowserConfig(config) {
+    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);
+    return {
+        ...DEFAULT_BROWSER_CONFIG,
+        ...(config ?? {}),
+        url: normalizedUrl,
+        chatgptUrl: normalizedUrl,
+        timeoutMs: config?.timeoutMs ?? DEFAULT_BROWSER_CONFIG.timeoutMs,
+        inputTimeoutMs: config?.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs,
+        cookieSync: config?.cookieSync ?? DEFAULT_BROWSER_CONFIG.cookieSync,
+        cookieNames: config?.cookieNames ?? DEFAULT_BROWSER_CONFIG.cookieNames,
+        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: config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel,
+        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,
+    };
+}

package/dist/src/browser/constants.js

@@ -0,0 +1,42 @@
+export const CHATGPT_URL = 'https://chatgpt.com/';
+export const DEFAULT_MODEL_TARGET = 'ChatGPT 5.1';
+export const COOKIE_URLS = ['https://chatgpt.com', 'https://chat.openai.com', 'https://atlas.openai.com'];
+export const INPUT_SELECTORS = [
+    'textarea[data-id="prompt-textarea"]',
+    'textarea[placeholder*="Send a message"]',
+    'textarea[aria-label="Message ChatGPT"]',
+    'textarea:not([disabled])',
+    'textarea[name="prompt-textarea"]',
+    '#prompt-textarea',
+    '.ProseMirror',
+    '[contenteditable="true"][data-virtualkeyboard="true"]',
+];
+export const ANSWER_SELECTORS = [
+    'article[data-testid^="conversation-turn"][data-message-author-role="assistant"]',
+    'article[data-testid^="conversation-turn"] [data-message-author-role="assistant"]',
+    'article[data-testid^="conversation-turn"] .markdown',
+    '[data-message-author-role="assistant"] .markdown',
+    '[data-message-author-role="assistant"]',
+];
+export const CONVERSATION_TURN_SELECTOR = 'article[data-testid^="conversation-turn"]';
+export const ASSISTANT_ROLE_SELECTOR = '[data-message-author-role="assistant"]';
+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 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-state="loading"]',
+    '[aria-live="polite"]',
+];
+export const STOP_BUTTON_SELECTOR = '[data-testid="stop-button"]';
+export const SEND_BUTTON_SELECTOR = '[data-testid="send-button"]';
+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.
+export const FINISHED_ACTIONS_SELECTOR = 'button[data-testid="copy-turn-action-button"], button[data-testid="good-response-turn-action-button"], button[data-testid="bad-response-turn-action-button"], button[aria-label="Share"]';