@steipete/oracle 1.0.8 → 1.1.0

package/dist/oracle/src/browser/cookies.js

@@ -0,0 +1,210 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { COOKIE_URLS } from './constants.js';
+export class ChromeCookieSyncError extends Error {
+}
+export async function syncCookies(Network, url, profile, logger, allowErrors = false) {
+    try {
+        const cookies = await readChromeCookies(url, profile);
+        if (!cookies.length) {
+            return 0;
+        }
+        let applied = 0;
+        for (const cookie of cookies) {
+            const cookieWithUrl = { ...cookie };
+            if (!cookieWithUrl.domain || cookieWithUrl.domain === 'localhost') {
+                cookieWithUrl.url = url;
+            }
+            else if (!cookieWithUrl.domain.startsWith('.')) {
+                cookieWithUrl.url = `https://${cookieWithUrl.domain}`;
+            }
+            try {
+                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 readChromeCookies(url, profile) {
+    const chromeModule = await loadChromeCookiesModule();
+    const urlsToCheck = Array.from(new Set([stripQuery(url), ...COOKIE_URLS]));
+    const merged = new Map();
+    for (const candidateUrl of urlsToCheck) {
+        let rawCookies;
+        rawCookies = await chromeModule.getCookiesPromised(candidateUrl, 'puppeteer', profile ?? undefined);
+        if (!Array.isArray(rawCookies)) {
+            continue;
+        }
+        const fallbackHostname = new URL(candidateUrl).hostname;
+        for (const cookie of rawCookies) {
+            const normalized = normalizeCookie(cookie, fallbackHostname);
+            if (!normalized) {
+                continue;
+            }
+            const key = `${normalized.domain ?? fallbackHostname}:${normalized.name}`;
+            if (!merged.has(key)) {
+                merged.set(key, normalized);
+            }
+        }
+    }
+    return Array.from(merged.values());
+}
+function normalizeCookie(cookie, fallbackHost) {
+    if (!cookie?.name) {
+        return null;
+    }
+    const domain = cookie.domain?.startsWith('.') ? cookie.domain : 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: cookie.value ?? '',
+        domain,
+        path: cookie.path ?? '/',
+        expires,
+        secure,
+        httpOnly,
+    };
+}
+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) {
+        return Math.round(value / 1_000_000 - 11644473600);
+    }
+    if (value > 1_000_000_000) {
+        return Math.round(value / 1000);
+    }
+    return Math.round(value);
+}
+const WORKSPACE_MANIFEST_PATH = fileURLToPath(new URL('../../pnpm-workspace.yaml', import.meta.url));
+const HAS_PNPM_WORKSPACE = existsSync(WORKSPACE_MANIFEST_PATH);
+const SQLITE_NODE_PATTERN = /node_sqlite3\.node/i;
+const SQLITE_BINDINGS_PATTERN = /bindings file/i;
+const SQLITE_SELF_REGISTER_PATTERN = /Module did not self-register/i;
+const SQLITE_BINDING_HINT = [
+    'Chrome cookie sync needs sqlite3 bindings for Node 25.',
+    'If the automatic rebuild fails, run:',
+    '  PYTHON=/usr/bin/python3 npm_config_build_from_source=1 pnpm rebuild chrome-cookies-secure sqlite3 keytar --workspace-root',
+].join('\n');
+let attemptedSqliteRebuild = false;
+async function loadChromeCookiesModule() {
+    let imported;
+    try {
+        imported = await import('chrome-cookies-secure');
+    }
+    catch (error) {
+        console.warn('Failed to load chrome-cookies-secure to copy cookies:', error);
+        if (isSqliteBindingError(error)) {
+            const rebuilt = await attemptSqliteRebuild();
+            if (rebuilt) {
+                return loadChromeCookiesModule();
+            }
+            console.warn(SQLITE_BINDING_HINT);
+        }
+        else {
+            console.warn('If this persists, run `pnpm rebuild chrome-cookies-secure sqlite3 keytar --workspace-root`.');
+        }
+        throw new ChromeCookieSyncError('Unable to load chrome-cookies-secure. Cookie copy is required.');
+    }
+    const secureModule = resolveChromeCookieModule(imported);
+    if (!secureModule) {
+        console.warn('chrome-cookies-secure does not expose getCookiesPromised(); skipping cookie copy.');
+        throw new ChromeCookieSyncError('chrome-cookies-secure did not expose getCookiesPromised');
+    }
+    return secureModule;
+}
+function resolveChromeCookieModule(candidate) {
+    if (hasGetCookiesPromised(candidate)) {
+        return candidate;
+    }
+    if (typeof candidate === 'object' && candidate !== null) {
+        const defaultExport = Reflect.get(candidate, 'default');
+        if (hasGetCookiesPromised(defaultExport)) {
+            return defaultExport;
+        }
+    }
+    return null;
+}
+function hasGetCookiesPromised(value) {
+    return Boolean(value && typeof value.getCookiesPromised === 'function');
+}
+function isSqliteBindingError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const message = error.message ?? '';
+    return (SQLITE_NODE_PATTERN.test(message) ||
+        SQLITE_BINDINGS_PATTERN.test(message) ||
+        SQLITE_SELF_REGISTER_PATTERN.test(message));
+}
+async function attemptSqliteRebuild() {
+    if (attemptedSqliteRebuild) {
+        return false;
+    }
+    attemptedSqliteRebuild = true;
+    if (process.env.ORACLE_ALLOW_SQLITE_REBUILD !== '1') {
+        console.warn('[oracle] sqlite3 bindings missing. Set ORACLE_ALLOW_SQLITE_REBUILD=1 if you want Oracle to attempt an automatic rebuild, or run `pnpm rebuild chrome-cookies-secure sqlite3 keytar --workspace-root` manually.');
+        return false;
+    }
+    const pnpmCommand = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
+    const args = ['rebuild', 'chrome-cookies-secure', 'sqlite3', 'keytar'];
+    if (HAS_PNPM_WORKSPACE) {
+        args.push('--workspace-root');
+    }
+    const childEnv = { ...process.env };
+    childEnv.npm_config_build_from_source = '1';
+    childEnv.PYTHON = childEnv.PYTHON ?? '/usr/bin/python3';
+    console.warn('[oracle] Attempting to rebuild sqlite3 bindings automatically…');
+    console.warn(`[oracle] Running: npm_config_build_from_source=1 PYTHON=${childEnv.PYTHON} ${pnpmCommand} ${args.join(' ')}`);
+    return new Promise((resolve) => {
+        const child = spawn(pnpmCommand, args, { stdio: 'inherit', env: childEnv });
+        child.on('exit', (code) => {
+            if (code === 0) {
+                console.warn('[oracle] sqlite3 rebuild completed successfully.');
+                resolve(true);
+            }
+            else {
+                console.warn('[oracle] sqlite3 rebuild failed with exit code', code ?? 0);
+                resolve(false);
+            }
+        });
+        child.on('error', (error) => {
+            console.warn('[oracle] Unable to spawn pnpm to rebuild sqlite3:', error);
+            resolve(false);
+        });
+    });
+}

package/dist/oracle/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
+    }
+}

package/dist/oracle/src/browser/index.js

@@ -0,0 +1,331 @@
+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 } from './chromeLifecycle.js';
+import { syncCookies } from './cookies.js';
+import { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, readAssistantSnapshot, } from './pageActions.js';
+import { estimateTokenCount, withRetries } from './utils.js';
+import { formatElapsed } from '../oracle/format.js';
+export { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
+export { parseDuration, delay } 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,
+        })}`);
+    }
+    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;
+    try {
+        client = await connectToChrome(chrome.port, logger);
+        const markConnectionLost = () => {
+            connectionClosedUnexpectedly = true;
+        };
+        client.on('disconnect', markConnectionLost);
+        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) {
+            const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, config.allowCookieErrors ?? false);
+            logger(cookieCount > 0
+                ? `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? 'Default'}`
+                : 'No Chrome cookies found; continuing without session reuse');
+        }
+        else {
+            logger('Skipping Chrome cookie sync (--browser-no-cookie-sync)');
+        }
+        await navigateToChatGPT(Page, Runtime, config.url, logger);
+        await ensureNotBlocked(Runtime, config.headless, logger);
+        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.');
+            }
+            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 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?.();
+        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}`);
+        }
+    }
+}
+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 barSegments = 10;
+    const filled = Math.round(progress * barSegments);
+    const bar = `${'█'.repeat(filled).padEnd(barSegments, '░')}`;
+    const pct = Math.round(progress * 100)
+        .toString()
+        .padStart(3, ' ');
+    const statusLabel = message ? ` — ${message}` : '';
+    return `[${elapsedText} / ~10m] ${bar} ${pct}%${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/oracle/src/browser/pageActions.js

@@ -0,0 +1,5 @@
+export { navigateToChatGPT, ensureNotBlocked, 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/oracle/src/browser/prompt.js

@@ -0,0 +1,88 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { readFiles, createFileSections, DEFAULT_SYSTEM_PROMPT, MODEL_CONFIGS, TOKENIZER_OPTIONS } from '../oracle.js';
+export async function assembleBrowserPrompt(runOptions, deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const readFilesFn = deps.readFilesImpl ?? readFiles;
+    const files = await readFilesFn(runOptions.file ?? [], { cwd });
+    const basePrompt = (runOptions.prompt ?? '').trim();
+    const userPrompt = basePrompt;
+    const systemPrompt = runOptions.system?.trim() || DEFAULT_SYSTEM_PROMPT;
+    const sections = createFileSections(files, cwd);
+    const lines = ['[SYSTEM]', systemPrompt, '', '[USER]', userPrompt, ''];
+    sections.forEach((section) => {
+        lines.push(`[FILE: ${section.displayPath}]`, section.content.trimEnd(), '');
+    });
+    const markdown = lines.join('\n').trimEnd();
+    const inlineFiles = Boolean(runOptions.browserInlineFiles);
+    const composerSections = [];
+    if (systemPrompt) {
+        composerSections.push(systemPrompt);
+    }
+    if (userPrompt) {
+        composerSections.push(userPrompt);
+    }
+    let inlineBlock = '';
+    if (inlineFiles && sections.length > 0) {
+        const inlineLines = [];
+        sections.forEach((section) => {
+            inlineLines.push(`[FILE: ${section.displayPath}]`, section.content.trimEnd(), '');
+        });
+        inlineBlock = inlineLines.join('\n').trim();
+        if (inlineBlock.length > 0) {
+            composerSections.push(inlineBlock);
+        }
+    }
+    const composerText = composerSections.join('\n\n').trim();
+    const attachments = inlineFiles
+        ? []
+        : sections.map((section) => ({
+            path: section.absolutePath,
+            displayPath: section.displayPath,
+            sizeBytes: Buffer.byteLength(section.content, 'utf8'),
+        }));
+    const MAX_BROWSER_ATTACHMENTS = 10;
+    if (!inlineFiles && attachments.length > MAX_BROWSER_ATTACHMENTS) {
+        const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-browser-bundle-'));
+        const bundlePath = path.join(bundleDir, 'attachments-bundle.txt');
+        const bundleLines = [];
+        sections.forEach((section) => {
+            bundleLines.push(`### File: ${section.displayPath}`);
+            bundleLines.push(section.content.trimEnd());
+            bundleLines.push('');
+        });
+        const bundleText = `${bundleLines.join('\n').trimEnd()}\n`;
+        await fs.writeFile(bundlePath, bundleText, 'utf8');
+        attachments.length = 0;
+        attachments.push({
+            path: bundlePath,
+            displayPath: 'attachments-bundle.txt',
+            sizeBytes: Buffer.byteLength(bundleText, 'utf8'),
+        });
+    }
+    const inlineFileCount = inlineFiles ? sections.length : 0;
+    const tokenizer = MODEL_CONFIGS[runOptions.model].tokenizer;
+    const tokenizerUserContent = inlineFileCount > 0 && inlineBlock
+        ? [userPrompt, inlineBlock].filter((value) => Boolean(value?.trim())).join('\n\n').trim()
+        : userPrompt;
+    const tokenizerMessages = [
+        systemPrompt ? { role: 'system', content: systemPrompt } : null,
+        tokenizerUserContent ? { role: 'user', content: tokenizerUserContent } : null,
+    ].filter(Boolean);
+    const estimatedInputTokens = tokenizer(tokenizerMessages.length > 0
+        ? tokenizerMessages
+        : [{ role: 'user', content: '' }], TOKENIZER_OPTIONS);
+    const tokenEstimateIncludesInlineFiles = inlineFileCount > 0 && Boolean(inlineBlock);
+    return {
+        markdown,
+        composerText,
+        estimatedInputTokens,
+        attachments,
+        inlineFileCount,
+        tokenEstimateIncludesInlineFiles,
+        bundled: !inlineFiles && attachments.length === 1 && sections.length > MAX_BROWSER_ATTACHMENTS && attachments[0]?.displayPath
+            ? { originalCount: sections.length, bundlePath: attachments[0].displayPath }
+            : null,
+    };
+}