@indykish/oracle 0.9.0

package/dist/src/browser/constants.js

@@ -0,0 +1,71 @@
+export const CHATGPT_URL = 'https://chatgpt.com/';
+export const DEFAULT_MODEL_TARGET = 'GPT-5.2 Pro';
+export const DEFAULT_MODEL_STRATEGY = 'select';
+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-turn="assistant"]',
+    'article[data-testid^="conversation-turn"] [data-message-author-role="assistant"]',
+    'article[data-testid^="conversation-turn"] [data-turn="assistant"]',
+    'article[data-testid^="conversation-turn"] .markdown',
+    '[data-message-author-role="assistant"] .markdown',
+    '[data-turn="assistant"] .markdown',
+    '[data-message-author-role="assistant"]',
+    '[data-turn="assistant"]',
+];
+export const CONVERSATION_TURN_SELECTOR = 'article[data-testid^="conversation-turn"], div[data-testid^="conversation-turn"], section[data-testid^="conversation-turn"], ' +
+    'article[data-message-author-role], div[data-message-author-role], section[data-message-author-role], ' +
+    'article[data-turn], div[data-turn], section[data-turn]';
+export const ASSISTANT_ROLE_SELECTOR = '[data-message-author-role="assistant"], [data-turn="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_SELECTORS = [
+    'form input[type="file"]:not([accept])',
+    'input[type="file"][multiple]:not([accept])',
+    'input[type="file"][multiple]',
+    'input[type="file"]:not([accept])',
+    'form input[type="file"][accept]',
+    'input[type="file"][accept]',
+    'input[type="file"]',
+    '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_SELECTORS = [
+    'button[data-testid="send-button"]',
+    'button[data-testid*="composer-send"]',
+    'form button[type="submit"]',
+    'button[type="submit"][data-testid*="send"]',
+    'button[aria-label*="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.
+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"]';

package/dist/src/browser/cookies.js

@@ -0,0 +1,191 @@
+import { COOKIE_URLS } from './constants.js';
+import { delay } from './utils.js';
+import { getCookies } from '@steipete/sweet-cookie';
+export class ChromeCookieSyncError extends Error {
+}
+export async function syncCookies(Network, url, profile, logger, options = {}) {
+    const { allowErrors = false, filterNames, inlineCookies, cookiePath, waitMs = 0 } = options;
+    try {
+        // Learned: inline cookies are the most deterministic (avoid Keychain + profile ambiguity).
+        const cookies = inlineCookies?.length
+            ? normalizeInlineCookies(inlineCookies, new URL(url).hostname)
+            : await readChromeCookiesWithWait(url, profile, filterNames ?? undefined, cookiePath ?? undefined, waitMs, logger);
+        if (!cookies.length) {
+            return 0;
+        }
+        let applied = 0;
+        for (const cookie of cookies) {
+            const cookieWithUrl = attachUrl(cookie, url);
+            try {
+                // Learned: CDP will silently drop cookies without a url; always attach one.
+                const result = await Network.setCookie(cookieWithUrl);
+                if (result?.success) {
+                    applied += 1;
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logger(`Failed to set cookie ${cookie.name}: ${message}`);
+            }
+        }
+        return applied;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (allowErrors) {
+            logger(`Cookie sync failed (continuing with override): ${message}`);
+            return 0;
+        }
+        throw error instanceof ChromeCookieSyncError ? error : new ChromeCookieSyncError(message);
+    }
+}
+async function readChromeCookiesWithWait(url, profile, filterNames, cookiePath, waitMs, logger) {
+    if (waitMs <= 0) {
+        return readChromeCookies(url, profile, filterNames, cookiePath);
+    }
+    let cookies = [];
+    let firstError;
+    try {
+        cookies = await readChromeCookies(url, profile, filterNames, cookiePath);
+    }
+    catch (error) {
+        firstError = error;
+    }
+    if (cookies.length > 0 && !firstError) {
+        return cookies;
+    }
+    const waitLabel = waitMs >= 1000 ? `${Math.round(waitMs / 1000)}s` : `${waitMs}ms`;
+    const message = firstError instanceof Error ? firstError.message : String(firstError ?? '');
+    if (firstError) {
+        logger(`[cookies] Cookie read failed (${message}); waiting ${waitLabel} then retrying once.`);
+    }
+    else {
+        logger(`[cookies] No cookies found; waiting ${waitLabel} then retrying once.`);
+    }
+    await delay(waitMs);
+    return readChromeCookies(url, profile, filterNames, cookiePath);
+}
+async function readChromeCookies(url, profile, filterNames, cookiePath) {
+    const origins = Array.from(new Set([stripQuery(url), ...COOKIE_URLS]));
+    const chromeProfile = cookiePath ?? profile ?? undefined;
+    const timeoutMs = readDuration('ORACLE_COOKIE_LOAD_TIMEOUT_MS', 5_000);
+    // Learned: read from multiple origins to capture auth cookies that land on chat.openai.com + atlas.
+    const { cookies, warnings } = await getCookies({
+        url,
+        origins,
+        names: filterNames?.length ? filterNames : undefined,
+        browsers: ['chrome'],
+        mode: 'merge',
+        chromeProfile,
+        timeoutMs,
+    });
+    if (process.env.ORACLE_DEBUG_COOKIES === '1' && warnings.length) {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] sweet-cookie warnings:\n- ${warnings.join('\n- ')}`);
+    }
+    const merged = new Map();
+    for (const cookie of cookies) {
+        const normalized = toCdpCookie(cookie);
+        if (!normalized)
+            continue;
+        const key = `${normalized.domain ?? ''}:${normalized.name}`;
+        if (!merged.has(key))
+            merged.set(key, normalized);
+    }
+    return Array.from(merged.values());
+}
+function normalizeInlineCookies(rawCookies, fallbackHost) {
+    const merged = new Map();
+    for (const cookie of rawCookies) {
+        if (!cookie?.name)
+            continue;
+        // Learned: inline cookies may omit url/domain; default to current host with a safe path.
+        const normalized = {
+            name: cookie.name,
+            value: cookie.value ?? '',
+            url: cookie.url,
+            domain: cookie.domain ?? fallbackHost,
+            path: cookie.path ?? '/',
+            expires: normalizeExpiration(cookie.expires),
+            secure: cookie.secure ?? true,
+            httpOnly: cookie.httpOnly ?? false,
+            sameSite: cookie.sameSite,
+        };
+        const key = `${normalized.domain ?? fallbackHost}:${normalized.name}`;
+        if (!merged.has(key)) {
+            merged.set(key, normalized);
+        }
+    }
+    return Array.from(merged.values());
+}
+function toCdpCookie(cookie) {
+    if (!cookie?.name)
+        return null;
+    const out = {
+        name: cookie.name,
+        value: cookie.value,
+        domain: cookie.domain,
+        path: cookie.path ?? '/',
+        secure: cookie.secure ?? true,
+        httpOnly: cookie.httpOnly ?? false,
+    };
+    if (typeof cookie.expires === 'number')
+        out.expires = cookie.expires;
+    if (cookie.sameSite === 'Lax' || cookie.sameSite === 'Strict' || cookie.sameSite === 'None') {
+        out.sameSite = cookie.sameSite;
+    }
+    return out;
+}
+function attachUrl(cookie, fallbackUrl) {
+    const cookieWithUrl = { ...cookie };
+    if (!cookieWithUrl.url) {
+        if (!cookieWithUrl.domain || cookieWithUrl.domain === 'localhost') {
+            cookieWithUrl.url = fallbackUrl;
+        }
+        else if (!cookieWithUrl.domain.startsWith('.')) {
+            cookieWithUrl.url = `https://${cookieWithUrl.domain}`;
+        }
+    }
+    // When url is present, let Chrome derive the host from it; keeping domain can trigger CDP sanitization errors.
+    if (cookieWithUrl.url) {
+        // Learned: CDP rejects cookies with both url + domain in some cases; drop domain to avoid failures.
+        delete cookieWithUrl.domain;
+    }
+    return cookieWithUrl;
+}
+function stripQuery(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.hash = '';
+        parsed.search = '';
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+}
+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) {
+        // Learned: Chrome may store WebKit microseconds since 1601; convert to Unix seconds.
+        return Math.round(value / 1_000_000 - 11644473600);
+    }
+    if (value > 1_000_000_000) {
+        // Likely milliseconds; normalize to seconds for CDP.
+        return Math.round(value / 1000);
+    }
+    return Math.round(value);
+}
+function readDuration(envKey, defaultValueMs) {
+    const raw = process.env[envKey];
+    if (!raw)
+        return defaultValueMs;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : defaultValueMs;
+}

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;
+}

package/dist/src/browser/domDebug.js

@@ -0,0 +1,36 @@
+import { CONVERSATION_TURN_SELECTOR } from './constants.js';
+export function buildConversationDebugExpression() {
+    return `(() => {
+    const CONVERSATION_SELECTOR = ${JSON.stringify(CONVERSATION_TURN_SELECTOR)};
+    const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+    return turns.map((node) => ({
+      role: node.getAttribute('data-message-author-role'),
+      text: node.innerText?.slice(0, 200),
+      testid: node.getAttribute('data-testid'),
+    }));
+  })()`;
+}
+export async function logConversationSnapshot(Runtime, logger) {
+    const expression = buildConversationDebugExpression();
+    const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+    if (Array.isArray(result.value)) {
+        const recent = result.value.slice(-3);
+        logger(`Conversation snapshot: ${JSON.stringify(recent)}`);
+    }
+}
+export async function logDomFailure(Runtime, logger, context) {
+    if (!logger?.verbose) {
+        return;
+    }
+    try {
+        const entry = `Browser automation failure (${context}); capturing DOM snapshot for debugging...`;
+        logger(entry);
+        if (logger.sessionLog && logger.sessionLog !== logger) {
+            logger.sessionLog(entry);
+        }
+        await logConversationSnapshot(Runtime, logger);
+    }
+    catch {
+        // ignore snapshot failures
+    }
+}