@steipete/oracle 0.4.0

package/dist/src/browser/index.js

@@ -0,0 +1,541 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { resolveBrowserConfig } from './config.js';
+import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChrome, connectToRemoteChrome, } 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 { formatElapsed } from '../oracle/format.js';
+import { CHATGPT_URL } from './constants.js';
+export { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
+export { parseDuration, delay, normalizeChatgptUrl } from './utils.js';
+export async function runBrowserMode(options) {
+    const promptText = options.prompt?.trim();
+    if (!promptText) {
+        throw new Error('Prompt text is required when using browser mode.');
+    }
+    const attachments = options.attachments ?? [];
+    const config = resolveBrowserConfig(options.config);
+    const logger = options.log ?? ((_message) => { });
+    if (logger.verbose === undefined) {
+        logger.verbose = Boolean(config.debug);
+    }
+    if (logger.sessionLog === undefined && options.log?.sessionLog) {
+        logger.sessionLog = options.log.sessionLog;
+    }
+    if (config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') {
+        logger(`[browser-mode] config: ${JSON.stringify({
+            ...config,
+            promptLength: promptText.length,
+        })}`);
+    }
+    // Remote Chrome mode - connect to existing browser
+    if (config.remoteChrome) {
+        // Warn about ignored local-only options
+        if (config.headless || config.hideWindow || config.keepBrowser || config.chromePath) {
+            logger('Note: --remote-chrome ignores local Chrome flags ' +
+                '(--browser-headless, --browser-hide-window, --browser-keep-browser, --browser-chrome-path).');
+        }
+        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);
+    let removeTerminationHooks = null;
+    try {
+        removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, config.keepBrowser, logger);
+    }
+    catch {
+        // ignore failure; cleanup still happens below
+    }
+    let client = null;
+    const startedAt = Date.now();
+    let answerText = '';
+    let answerMarkdown = '';
+    let answerHtml = '';
+    let runStatus = 'attempted';
+    let connectionClosedUnexpectedly = false;
+    let stopThinkingMonitor = null;
+    let appliedCookies = 0;
+    try {
+        client = await connectToChrome(chrome.port, logger);
+        const disconnectPromise = new Promise((_, reject) => {
+            client?.on('disconnect', () => {
+                connectionClosedUnexpectedly = true;
+                logger('Chrome window closed; attempting to abort run.');
+                reject(new Error('Chrome window closed before oracle finished. Please keep it open until completion.'));
+            });
+        });
+        const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
+        const { Network, Page, Runtime, Input, DOM } = client;
+        if (!config.headless && config.hideWindow) {
+            await hideChromeWindow(chrome, logger);
+        }
+        const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
+        if (DOM && typeof DOM.enable === 'function') {
+            domainEnablers.push(DOM.enable());
+        }
+        await Promise.all(domainEnablers);
+        await Network.clearBrowserCookies();
+        if (config.cookieSync) {
+            if (!config.inlineCookies) {
+                logger('Heads-up: macOS may prompt for your Keychain password to read Chrome cookies; use --copy or --render for manual flow.');
+            }
+            else {
+                logger('Applying inline cookies (skipping Chrome profile read and Keychain prompt)');
+            }
+            const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, {
+                allowErrors: config.allowCookieErrors ?? false,
+                filterNames: config.cookieNames ?? undefined,
+                inlineCookies: config.inlineCookies ?? undefined,
+                cookiePath: config.chromeCookiePath ?? undefined,
+            });
+            appliedCookies = cookieCount;
+            if (config.inlineCookies && cookieCount === 0) {
+                throw new Error('No inline cookies were applied; aborting before navigation.');
+            }
+            logger(cookieCount > 0
+                ? config.inlineCookies
+                    ? `Applied ${cookieCount} inline cookies`
+                    : `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
+                : config.inlineCookies
+                    ? 'No inline cookies applied; continuing without session reuse'
+                    : 'No Chrome cookies found; continuing without session reuse');
+        }
+        else {
+            logger('Skipping Chrome cookie sync (--browser-no-cookie-sync)');
+        }
+        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 }));
+        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)`);
+        if (config.desiredModel) {
+            await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger), {
+                retries: 2,
+                delayMs: 300,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Model picker attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            })).catch((error) => {
+                const base = error instanceof Error ? error.message : String(error);
+                const hint = appliedCookies === 0
+                    ? ' No cookies were applied; log in to ChatGPT in Chrome or provide inline cookies (--browser-inline-cookies[(-file)] or ORACLE_BROWSER_COOKIES_JSON).'
+                    : '';
+                throw new Error(`${base}${hint}`);
+            });
+            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+            logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
+        }
+        if (attachments.length > 0) {
+            if (!DOM) {
+                throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+            }
+            for (const attachment of attachments) {
+                logger(`Uploading attachment: ${attachment.displayPath}`);
+                await uploadAttachmentFile({ runtime: Runtime, dom: DOM }, attachment, logger);
+            }
+            const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
+            await raceWithDisconnect(waitForAttachmentCompletion(Runtime, waitBudget, logger));
+            logger('All attachments uploaded');
+        }
+        await raceWithDisconnect(submitPrompt({ runtime: Runtime, input: Input }, promptText, logger));
+        stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
+        const answer = await raceWithDisconnect(waitForAssistantResponse(Runtime, config.timeoutMs, logger));
+        answerText = answer.text;
+        answerHtml = answer.html ?? '';
+        const copiedMarkdown = await raceWithDisconnect(withRetries(async () => {
+            const attempt = await captureAssistantMarkdown(Runtime, answer.meta, logger);
+            if (!attempt) {
+                throw new Error('copy-missing');
+            }
+            return attempt;
+        }, {
+            retries: 2,
+            delayMs: 350,
+            onRetry: (attempt, error) => {
+                if (options.verbose) {
+                    logger(`[retry] Markdown capture attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                }
+            },
+        })).catch(() => null);
+        answerMarkdown = copiedMarkdown ?? answerText;
+        // Final sanity check: ensure we didn't accidentally capture the user prompt instead of the assistant turn.
+        const finalSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
+        const finalText = typeof finalSnapshot?.text === 'string' ? finalSnapshot.text.trim() : '';
+        if (finalText &&
+            finalText !== answerMarkdown.trim() &&
+            finalText !== promptText.trim() &&
+            finalText.length >= answerMarkdown.trim().length) {
+            logger('Refreshed assistant response via final DOM snapshot');
+            answerText = finalText;
+            answerMarkdown = finalText;
+        }
+        if (answerMarkdown.trim() === promptText.trim()) {
+            const deadline = Date.now() + 8_000;
+            let bestText = null;
+            let stableCount = 0;
+            while (Date.now() < deadline) {
+                const snapshot = await readAssistantSnapshot(Runtime).catch(() => null);
+                const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+                if (text && text !== promptText.trim()) {
+                    if (!bestText || text.length > bestText.length) {
+                        bestText = text;
+                        stableCount = 0;
+                    }
+                    else if (text === bestText) {
+                        stableCount += 1;
+                    }
+                    if (stableCount >= 2) {
+                        break;
+                    }
+                }
+                await new Promise((resolve) => setTimeout(resolve, 300));
+            }
+            if (bestText) {
+                logger('Recovered assistant response after detecting prompt echo');
+                answerText = bestText;
+                answerMarkdown = bestText;
+            }
+        }
+        stopThinkingMonitor?.();
+        runStatus = 'complete';
+        const durationMs = Date.now() - startedAt;
+        const answerChars = answerText.length;
+        const answerTokens = estimateTokenCount(answerMarkdown);
+        return {
+            answerText,
+            answerMarkdown,
+            answerHtml: answerHtml.length > 0 ? answerHtml : undefined,
+            tookMs: durationMs,
+            answerTokens,
+            answerChars,
+            chromePid: chrome.pid,
+            chromePort: chrome.port,
+            userDataDir,
+        };
+    }
+    catch (error) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        stopThinkingMonitor?.();
+        const socketClosed = connectionClosedUnexpectedly || isWebSocketClosureError(normalizedError);
+        connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
+        if (!socketClosed) {
+            logger(`Failed to complete ChatGPT run: ${normalizedError.message}`);
+            if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
+                logger(normalizedError.stack);
+            }
+            throw normalizedError;
+        }
+        if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
+            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,
+        });
+    }
+    finally {
+        try {
+            if (!connectionClosedUnexpectedly) {
+                await client?.close();
+            }
+        }
+        catch {
+            // ignore
+        }
+        removeTerminationHooks?.();
+        if (!config.keepBrowser) {
+            if (!connectionClosedUnexpectedly) {
+                try {
+                    await chrome.kill();
+                }
+                catch {
+                    // ignore kill failures
+                }
+            }
+            await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+            if (!connectionClosedUnexpectedly) {
+                const totalSeconds = (Date.now() - startedAt) / 1000;
+                logger(`Cleanup ${runStatus} • ${totalSeconds.toFixed(1)}s total`);
+            }
+        }
+        else if (!connectionClosedUnexpectedly) {
+            logger(`Chrome left running on port ${chrome.port} with profile ${userDataDir}`);
+        }
+    }
+}
+async function runRemoteBrowserMode(promptText, attachments, config, logger, options) {
+    const remoteChromeConfig = config.remoteChrome;
+    if (!remoteChromeConfig) {
+        throw new Error('Remote Chrome configuration missing. Pass --remote-chrome <host:port> to use this mode.');
+    }
+    const { host, port } = remoteChromeConfig;
+    logger(`Connecting to remote Chrome at ${host}:${port}`);
+    let client = null;
+    const startedAt = Date.now();
+    let answerText = '';
+    let answerMarkdown = '';
+    let answerHtml = '';
+    let connectionClosedUnexpectedly = false;
+    let stopThinkingMonitor = null;
+    try {
+        client = await connectToRemoteChrome(host, port, logger);
+        const markConnectionLost = () => {
+            connectionClosedUnexpectedly = true;
+        };
+        client.on('disconnect', markConnectionLost);
+        const { Network, Page, Runtime, Input, DOM } = client;
+        const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
+        if (DOM && typeof DOM.enable === 'function') {
+            domainEnablers.push(DOM.enable());
+        }
+        await Promise.all(domainEnablers);
+        // Skip cookie sync for remote Chrome - it already has cookies
+        logger('Skipping cookie sync for remote Chrome (using existing session)');
+        await navigateToChatGPT(Page, Runtime, config.url, logger);
+        await ensureNotBlocked(Runtime, config.headless, logger);
+        await ensureLoggedIn(Runtime, logger, { remoteSession: true });
+        await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+        logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
+        if (config.desiredModel) {
+            await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger), {
+                retries: 2,
+                delayMs: 300,
+                onRetry: (attempt, error) => {
+                    if (options.verbose) {
+                        logger(`[retry] Model picker attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                    }
+                },
+            });
+            await ensurePromptReady(Runtime, config.inputTimeoutMs, logger);
+            logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
+        }
+        if (attachments.length > 0) {
+            if (!DOM) {
+                throw new Error('Chrome DOM domain unavailable while uploading attachments.');
+            }
+            // Use remote file transfer for remote Chrome (reads local files and injects via CDP)
+            for (const attachment of attachments) {
+                logger(`Uploading attachment: ${attachment.displayPath}`);
+                await uploadAttachmentViaDataTransfer({ runtime: Runtime, dom: DOM }, attachment, logger);
+            }
+            const waitBudget = Math.max(config.inputTimeoutMs ?? 30_000, 30_000);
+            await waitForAttachmentCompletion(Runtime, waitBudget, logger);
+            logger('All attachments uploaded');
+        }
+        await submitPrompt({ runtime: Runtime, input: Input }, promptText, logger);
+        stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
+        const answer = await waitForAssistantResponse(Runtime, config.timeoutMs, logger);
+        answerText = answer.text;
+        answerHtml = answer.html ?? '';
+        const copiedMarkdown = await withRetries(async () => {
+            const attempt = await captureAssistantMarkdown(Runtime, answer.meta, logger);
+            if (!attempt) {
+                throw new Error('copy-missing');
+            }
+            return attempt;
+        }, {
+            retries: 2,
+            delayMs: 350,
+            onRetry: (attempt, error) => {
+                if (options.verbose) {
+                    logger(`[retry] Markdown capture attempt ${attempt + 1}: ${error instanceof Error ? error.message : error}`);
+                }
+            },
+        }).catch(() => null);
+        answerMarkdown = copiedMarkdown ?? answerText;
+        stopThinkingMonitor?.();
+        const durationMs = Date.now() - startedAt;
+        const answerChars = answerText.length;
+        const answerTokens = estimateTokenCount(answerMarkdown);
+        return {
+            answerText,
+            answerMarkdown,
+            answerHtml: answerHtml.length > 0 ? answerHtml : undefined,
+            tookMs: durationMs,
+            answerTokens,
+            answerChars,
+            chromePid: undefined,
+            chromePort: port,
+            userDataDir: undefined,
+        };
+    }
+    catch (error) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        stopThinkingMonitor?.();
+        const socketClosed = connectionClosedUnexpectedly || isWebSocketClosureError(normalizedError);
+        connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
+        if (!socketClosed) {
+            logger(`Failed to complete ChatGPT run: ${normalizedError.message}`);
+            if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === '1') && normalizedError.stack) {
+                logger(normalizedError.stack);
+            }
+            throw normalizedError;
+        }
+        throw new Error('Remote Chrome connection lost before Oracle finished.', {
+            cause: normalizedError,
+        });
+    }
+    finally {
+        try {
+            if (!connectionClosedUnexpectedly && client) {
+                await client.close();
+            }
+        }
+        catch {
+            // ignore
+        }
+        // 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`);
+    }
+}
+export { estimateTokenCount } from './utils.js';
+export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from './config.js';
+export { syncCookies } from './cookies.js';
+export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from './pageActions.js';
+function isWebSocketClosureError(error) {
+    const message = error.message.toLowerCase();
+    return (message.includes('websocket connection closed') ||
+        message.includes('websocket is closed') ||
+        message.includes('websocket error') ||
+        message.includes('target closed'));
+}
+export function formatThinkingLog(startedAt, now, message, locatorSuffix) {
+    const elapsedMs = now - startedAt;
+    const elapsedText = formatElapsed(elapsedMs);
+    const progress = Math.min(1, elapsedMs / 600_000); // soft target: 10 minutes
+    const pct = Math.round(progress * 100)
+        .toString()
+        .padStart(3, ' ');
+    const statusLabel = message ? ` — ${message}` : '';
+    return `${pct}% [${elapsedText} / ~10m]${statusLabel}${locatorSuffix}`;
+}
+function startThinkingStatusMonitor(Runtime, logger, includeDiagnostics = false) {
+    let stopped = false;
+    let pending = false;
+    let lastMessage = null;
+    const startedAt = Date.now();
+    const interval = setInterval(async () => {
+        // biome-ignore lint/nursery/noUnnecessaryConditions: stop flag flips asynchronously
+        if (stopped || pending) {
+            return;
+        }
+        pending = true;
+        try {
+            const nextMessage = await readThinkingStatus(Runtime);
+            if (nextMessage && nextMessage !== lastMessage) {
+                lastMessage = nextMessage;
+                let locatorSuffix = '';
+                if (includeDiagnostics) {
+                    try {
+                        const snapshot = await readAssistantSnapshot(Runtime);
+                        locatorSuffix = ` | assistant-turn=${snapshot ? 'present' : 'missing'}`;
+                    }
+                    catch {
+                        locatorSuffix = ' | assistant-turn=error';
+                    }
+                }
+                logger(formatThinkingLog(startedAt, Date.now(), nextMessage, locatorSuffix));
+            }
+        }
+        catch {
+            // ignore DOM polling errors
+        }
+        finally {
+            pending = false;
+        }
+    }, 1500);
+    interval.unref?.();
+    return () => {
+        // biome-ignore lint/nursery/noUnnecessaryConditions: multiple callers may race to stop
+        if (stopped) {
+            return;
+        }
+        stopped = true;
+        clearInterval(interval);
+    };
+}
+async function readThinkingStatus(Runtime) {
+    const expression = buildThinkingStatusExpression();
+    try {
+        const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+        const value = typeof result.value === 'string' ? result.value.trim() : '';
+        const sanitized = sanitizeThinkingText(value);
+        return sanitized || null;
+    }
+    catch {
+        return null;
+    }
+}
+function sanitizeThinkingText(raw) {
+    if (!raw) {
+        return '';
+    }
+    const trimmed = raw.trim();
+    const prefixPattern = /^(pro thinking)\s*[•:\-–—]*\s*/i;
+    if (prefixPattern.test(trimmed)) {
+        return trimmed.replace(prefixPattern, '').trim();
+    }
+    return trimmed;
+}
+function buildThinkingStatusExpression() {
+    const selectors = [
+        'span.loading-shimmer',
+        'span.flex.items-center.gap-1.truncate.text-start.align-middle.text-token-text-tertiary',
+        '[data-testid*="thinking"]',
+        '[data-testid*="reasoning"]',
+        '[role="status"]',
+        '[aria-live="polite"]',
+    ];
+    const keywords = ['pro thinking', 'thinking', 'reasoning', 'clarifying', 'planning', 'drafting', 'summarizing'];
+    const selectorLiteral = JSON.stringify(selectors);
+    const keywordsLiteral = JSON.stringify(keywords);
+    return `(() => {
+    const selectors = ${selectorLiteral};
+    const keywords = ${keywordsLiteral};
+    const nodes = new Set();
+    for (const selector of selectors) {
+      document.querySelectorAll(selector).forEach((node) => nodes.add(node));
+    }
+    document.querySelectorAll('[data-testid]').forEach((node) => nodes.add(node));
+    for (const node of nodes) {
+      if (!(node instanceof HTMLElement)) {
+        continue;
+      }
+      const text = node.textContent?.trim();
+      if (!text) {
+        continue;
+      }
+      const classLabel = (node.className || '').toLowerCase();
+      const dataLabel = ((node.getAttribute('data-testid') || '') + ' ' + (node.getAttribute('aria-label') || ''))
+        .toLowerCase();
+      const normalizedText = text.toLowerCase();
+      const matches = keywords.some((keyword) =>
+        normalizedText.includes(keyword) || classLabel.includes(keyword) || dataLabel.includes(keyword)
+      );
+      if (matches) {
+        const shimmerChild = node.querySelector(
+          'span.flex.items-center.gap-1.truncate.text-start.align-middle.text-token-text-tertiary',
+        );
+        if (shimmerChild?.textContent?.trim()) {
+          return shimmerChild.textContent.trim();
+        }
+        return text.trim();
+      }
+    }
+    return null;
+  })()`;
+}

package/dist/src/browser/keytarShim.js

@@ -0,0 +1,56 @@
+const defaultLabels = [
+    { 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' },
+];
+function loadEnvLabels() {
+    const raw = process.env.ORACLE_KEYCHAIN_LABELS;
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            return parsed
+                .map((entry) => (entry && typeof entry === 'object' ? entry : null))
+                .filter((entry) => Boolean(entry?.service && entry?.account));
+        }
+    }
+    catch {
+        // ignore invalid env payload
+    }
+    return [];
+}
+const fallbackLabels = [...loadEnvLabels(), ...defaultLabels];
+const disableKeytar = process.env.ORACLE_DISABLE_KEYTAR === '1' || process.env.CI === 'true';
+let keytar;
+if (disableKeytar) {
+    keytar = {
+        getPassword: async () => null,
+        setPassword: async () => undefined,
+        deletePassword: async () => false,
+    };
+}
+else {
+    const keytarModule = await import('keytar');
+    keytar = (keytarModule.default ?? keytarModule);
+    const originalGetPassword = keytar.getPassword.bind(keytar);
+    keytar.getPassword = async (service, account) => {
+        const primary = await originalGetPassword(service, account);
+        if (primary) {
+            return primary;
+        }
+        for (const label of fallbackLabels) {
+            if (label.service === service && label.account === account) {
+                continue; // already tried
+            }
+            const value = await originalGetPassword(label.service, label.account);
+            if (value) {
+                return value;
+            }
+        }
+        return null;
+    };
+}
+export default keytar;

package/dist/src/browser/pageActions.js

@@ -0,0 +1,5 @@
+export { navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady } from './actions/navigation.js';
+export { ensureModelSelection } from './actions/modelSelection.js';
+export { submitPrompt } from './actions/promptComposer.js';
+export { uploadAttachmentFile, waitForAttachmentCompletion } from './actions/attachments.js';
+export { waitForAssistantResponse, readAssistantSnapshot, captureAssistantMarkdown, buildAssistantExtractorForTest, buildConversationDebugExpressionForTest, } from './actions/assistantResponse.js';

package/dist/src/browser/policies.js

@@ -0,0 +1,43 @@
+import { formatFileSection } from '../oracle/markdown.js';
+export function buildAttachmentPlan(sections, { inlineFiles, bundleRequested, maxAttachments = 10, }) {
+    if (inlineFiles) {
+        const inlineLines = [];
+        sections.forEach((section) => {
+            inlineLines.push(formatFileSection(section.displayPath, section.content).trimEnd(), '');
+        });
+        const inlineBlock = inlineLines.join('\n').trim();
+        return {
+            mode: 'inline',
+            inlineBlock,
+            inlineFileCount: sections.length,
+            attachments: [],
+            shouldBundle: false,
+        };
+    }
+    const attachments = sections.map((section) => ({
+        path: section.absolutePath,
+        displayPath: section.displayPath,
+        sizeBytes: Buffer.byteLength(section.content, 'utf8'),
+    }));
+    const shouldBundle = bundleRequested || attachments.length > maxAttachments;
+    return {
+        mode: shouldBundle ? 'bundle' : 'upload',
+        inlineBlock: '',
+        inlineFileCount: 0,
+        attachments,
+        shouldBundle,
+    };
+}
+export function buildCookiePlan(config) {
+    if (config?.inlineCookies && config.inlineCookies.length > 0) {
+        const source = config.inlineCookiesSource ?? 'inline';
+        return { type: 'inline', description: `Cookies: inline payload (${config.inlineCookies.length}) via ${source}.` };
+    }
+    if (config?.cookieSync === false) {
+        return { type: 'disabled', description: 'Cookies: sync disabled (--browser-no-cookie-sync).' };
+    }
+    const allowlist = config?.cookieNames && config.cookieNames.length > 0
+        ? config.cookieNames.join(', ')
+        : 'all from Chrome profile';
+    return { type: 'copy', description: `Cookies: copy from Chrome (${allowlist}).` };
+}