@indykish/oracle 0.9.0

package/dist/src/browser/reattach.js

@@ -0,0 +1,186 @@
+import CDP from 'chrome-remote-interface';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdtemp, mkdir, rm } from 'node:fs/promises';
+import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, } from './pageActions.js';
+import { launchChrome, connectToChrome, hideChromeWindow } from './chromeLifecycle.js';
+import { resolveBrowserConfig } from './config.js';
+import { syncCookies } from './cookies.js';
+import { CHATGPT_URL } from './constants.js';
+import { cleanupStaleProfileState } from './profileState.js';
+import { pickTarget, extractConversationIdFromUrl, buildConversationUrl, withTimeout, openConversationFromSidebar, openConversationFromSidebarWithRetry, waitForLocationChange, readConversationTurnIndex, buildPromptEchoMatcher, recoverPromptEcho, alignPromptEchoMarkdown, } from './reattachHelpers.js';
+export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
+    const recoverSession = deps.recoverSession ??
+        (async (runtimeMeta, configMeta) => resumeBrowserSessionViaNewChrome(runtimeMeta, configMeta, logger, deps));
+    if (!runtime.chromePort) {
+        logger('No running Chrome detected; reopening browser to locate the session.');
+        return recoverSession(runtime, config);
+    }
+    const host = runtime.chromeHost ?? '127.0.0.1';
+    try {
+        const listTargets = deps.listTargets ??
+            (async () => {
+                const targets = await CDP.List({ host, port: runtime.chromePort });
+                return targets;
+            });
+        const connect = deps.connect ?? ((options) => CDP(options));
+        const targetList = (await listTargets());
+        const target = pickTarget(targetList, runtime);
+        const client = (await connect({
+            host,
+            port: runtime.chromePort,
+            target: target?.targetId,
+        }));
+        const { Runtime, DOM } = client;
+        if (Runtime?.enable) {
+            await Runtime.enable();
+        }
+        if (DOM && typeof DOM.enable === 'function') {
+            await DOM.enable();
+        }
+        const ensureConversationOpen = async () => {
+            const { result } = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
+            const href = typeof result?.value === 'string' ? result.value : '';
+            if (href.includes('/c/')) {
+                const currentId = extractConversationIdFromUrl(href);
+                if (!runtime.conversationId || (currentId && currentId === runtime.conversationId)) {
+                    return;
+                }
+            }
+            const opened = await openConversationFromSidebarWithRetry(Runtime, {
+                conversationId: runtime.conversationId ?? extractConversationIdFromUrl(runtime.tabUrl ?? ''),
+                preferProjects: true,
+                promptPreview: deps.promptPreview,
+            }, 15_000);
+            if (!opened) {
+                throw new Error('Unable to locate prior ChatGPT conversation in sidebar.');
+            }
+            await waitForLocationChange(Runtime, 15_000);
+        };
+        const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
+        const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
+        const timeoutMs = config?.timeoutMs ?? 120_000;
+        const pingTimeoutMs = Math.min(5_000, Math.max(1_500, Math.floor(timeoutMs * 0.05)));
+        await withTimeout(Runtime.evaluate({ expression: '1+1', returnByValue: true }), pingTimeoutMs, 'Reattach target did not respond');
+        await ensureConversationOpen();
+        const minTurnIndex = await readConversationTurnIndex(Runtime, logger);
+        const promptEcho = buildPromptEchoMatcher(deps.promptPreview);
+        const answer = await withTimeout(waitForResponse(Runtime, timeoutMs, logger, minTurnIndex ?? undefined), timeoutMs + 5_000, 'Reattach response timed out');
+        const recovered = await recoverPromptEcho(Runtime, answer, promptEcho, logger, minTurnIndex, timeoutMs);
+        const markdown = (await withTimeout(captureMarkdown(Runtime, recovered.meta, logger), 15_000, 'Reattach markdown capture timed out')) ?? recovered.text;
+        const aligned = alignPromptEchoMarkdown(recovered.text, markdown, promptEcho, logger);
+        if (client && typeof client.close === 'function') {
+            try {
+                await client.close();
+            }
+            catch {
+                // ignore
+            }
+        }
+        return { answerText: aligned.answerText, answerMarkdown: aligned.answerMarkdown };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Existing Chrome reattach failed (${message}); reopening browser to locate the session.`);
+        return recoverSession(runtime, config);
+    }
+}
+async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
+    const resolved = resolveBrowserConfig(config ?? {});
+    const manualLogin = Boolean(resolved.manualLogin);
+    const userDataDir = manualLogin
+        ? resolved.manualLoginProfileDir ?? path.join(os.homedir(), '.oracle', 'browser-profile')
+        : await mkdtemp(path.join(os.tmpdir(), 'oracle-reattach-'));
+    if (manualLogin) {
+        await mkdir(userDataDir, { recursive: true });
+    }
+    const chrome = await launchChrome(resolved, userDataDir, logger);
+    const chromeHost = chrome.host ?? '127.0.0.1';
+    const client = await connectToChrome(chrome.port, logger, chromeHost);
+    const { Network, Page, Runtime, DOM } = client;
+    if (Runtime?.enable) {
+        await Runtime.enable();
+    }
+    if (DOM && typeof DOM.enable === 'function') {
+        await DOM.enable();
+    }
+    if (!resolved.headless && resolved.hideWindow) {
+        await hideChromeWindow(chrome, logger);
+    }
+    let appliedCookies = 0;
+    if (!manualLogin && resolved.cookieSync) {
+        appliedCookies = await syncCookies(Network, resolved.url, resolved.chromeProfile, logger, {
+            allowErrors: resolved.allowCookieErrors,
+            filterNames: resolved.cookieNames ?? undefined,
+            inlineCookies: resolved.inlineCookies ?? undefined,
+            cookiePath: resolved.chromeCookiePath ?? undefined,
+            waitMs: resolved.cookieSyncWaitMs ?? 0,
+        });
+    }
+    await navigateToChatGPT(Page, Runtime, CHATGPT_URL, logger);
+    await ensureNotBlocked(Runtime, resolved.headless, logger);
+    await ensureLoggedIn(Runtime, logger, { appliedCookies });
+    if (resolved.url !== CHATGPT_URL) {
+        await navigateToChatGPT(Page, Runtime, resolved.url, logger);
+        await ensureNotBlocked(Runtime, resolved.headless, logger);
+    }
+    await ensurePromptReady(Runtime, resolved.inputTimeoutMs, logger);
+    const conversationUrl = buildConversationUrl(runtime, resolved.url);
+    if (conversationUrl) {
+        logger(`Reopening conversation at ${conversationUrl}`);
+        await navigateToChatGPT(Page, Runtime, conversationUrl, logger);
+        await ensureNotBlocked(Runtime, resolved.headless, logger);
+        await ensurePromptReady(Runtime, resolved.inputTimeoutMs, logger);
+    }
+    else {
+        const opened = await openConversationFromSidebarWithRetry(Runtime, {
+            conversationId: runtime.conversationId ?? extractConversationIdFromUrl(runtime.tabUrl ?? ''),
+            preferProjects: resolved.url !== CHATGPT_URL ||
+                Boolean(runtime.tabUrl && (/\/g\//.test(runtime.tabUrl) || runtime.tabUrl.includes('/project'))),
+            promptPreview: deps.promptPreview,
+        }, 15_000);
+        if (!opened) {
+            throw new Error('Unable to locate prior ChatGPT conversation in sidebar.');
+        }
+        await waitForLocationChange(Runtime, 15_000);
+    }
+    const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
+    const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
+    const timeoutMs = resolved.timeoutMs ?? 120_000;
+    const minTurnIndex = await readConversationTurnIndex(Runtime, logger);
+    const promptEcho = buildPromptEchoMatcher(deps.promptPreview);
+    const answer = await waitForResponse(Runtime, timeoutMs, logger, minTurnIndex ?? undefined);
+    const recovered = await recoverPromptEcho(Runtime, answer, promptEcho, logger, minTurnIndex, timeoutMs);
+    const markdown = (await captureMarkdown(Runtime, recovered.meta, logger)) ?? recovered.text;
+    const aligned = alignPromptEchoMarkdown(recovered.text, markdown, promptEcho, logger);
+    if (client && typeof client.close === 'function') {
+        try {
+            await client.close();
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!resolved.keepBrowser) {
+        try {
+            await chrome.kill();
+        }
+        catch {
+            // ignore
+        }
+        if (manualLogin) {
+            await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'never' }).catch(() => undefined);
+        }
+        else {
+            await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+    return { answerText: aligned.answerText, answerMarkdown: aligned.answerMarkdown };
+}
+// biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
+export const __test__ = {
+    pickTarget,
+    extractConversationIdFromUrl,
+    buildConversationUrl,
+    openConversationFromSidebar,
+};

package/dist/src/browser/reattachHelpers.js

@@ -0,0 +1,382 @@
+import { CONVERSATION_TURN_SELECTOR } from './constants.js';
+import { delay } from './utils.js';
+import { readAssistantSnapshot } from './pageActions.js';
+export function pickTarget(targets, runtime) {
+    if (!Array.isArray(targets) || targets.length === 0) {
+        return undefined;
+    }
+    if (runtime.chromeTargetId) {
+        const byId = targets.find((t) => t.targetId === runtime.chromeTargetId);
+        if (byId)
+            return byId;
+    }
+    if (runtime.tabUrl) {
+        const byUrl = targets.find((t) => t.url?.startsWith(runtime.tabUrl)) ||
+            targets.find((t) => runtime.tabUrl.startsWith(t.url || ''));
+        if (byUrl)
+            return byUrl;
+    }
+    return targets.find((t) => t.type === 'page') ?? targets[0];
+}
+export function extractConversationIdFromUrl(url) {
+    if (!url)
+        return undefined;
+    const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
+    return match?.[1];
+}
+export function buildConversationUrl(runtime, baseUrl) {
+    if (runtime.tabUrl) {
+        if (runtime.tabUrl.includes('/c/')) {
+            return runtime.tabUrl;
+        }
+        return null;
+    }
+    const conversationId = runtime.conversationId;
+    if (!conversationId) {
+        return null;
+    }
+    try {
+        const base = new URL(baseUrl);
+        const pathRoot = base.pathname.replace(/\/$/, '');
+        const prefix = pathRoot === '/' ? '' : pathRoot;
+        return `${base.origin}${prefix}/c/${conversationId}`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function withTimeout(task, ms, label) {
+    let timeoutId;
+    const timeout = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(label)), ms);
+    });
+    return Promise.race([task, timeout]).finally(() => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    });
+}
+export async function openConversationFromSidebar(Runtime, options, attempt = 0) {
+    const response = await Runtime.evaluate({
+        expression: `(() => {
+      const conversationId = ${JSON.stringify(options.conversationId ?? null)};
+      const preferProjects = ${JSON.stringify(Boolean(options.preferProjects))};
+      const promptPreview = ${JSON.stringify(options.promptPreview ?? null)};
+      const attemptIndex = ${Math.max(0, attempt)};
+      const promptNeedleFull = promptPreview ? promptPreview.trim().toLowerCase().slice(0, 100) : '';
+      const promptNeedleShort = promptNeedleFull.replace(/\\s*\\d{4,}\\s*$/, '').trim();
+      const promptNeedles = Array.from(new Set([promptNeedleFull, promptNeedleShort].filter(Boolean)));
+      const nav = document.querySelector('nav') || document.querySelector('aside') || document.body;
+      if (preferProjects) {
+        const projectLink = Array.from(nav.querySelectorAll('a,button'))
+          .find((el) => (el.textContent || '').trim().toLowerCase() === 'projects');
+        if (projectLink) {
+          projectLink.click();
+        }
+      }
+      const allElements = Array.from(
+        document.querySelectorAll(
+          'a,button,[role="link"],[role="button"],[data-href],[data-url],[data-conversation-id],[data-testid*="conversation"],[data-testid*="history"]',
+        ),
+      );
+      const getHref = (el) =>
+        el.getAttribute('href') ||
+        el.getAttribute('data-href') ||
+        el.getAttribute('data-url') ||
+        el.dataset?.href ||
+        el.dataset?.url ||
+        '';
+      const toCandidate = (el) => {
+        const clickable = el.closest('a,button,[role="link"],[role="button"]') || el;
+        const rawText = (el.textContent || clickable.textContent || '').trim();
+        return {
+          el,
+          clickable,
+          href: getHref(clickable) || getHref(el),
+          conversationId:
+            clickable.getAttribute('data-conversation-id') ||
+            el.getAttribute('data-conversation-id') ||
+            clickable.dataset?.conversationId ||
+            el.dataset?.conversationId ||
+            '',
+          testId: clickable.getAttribute('data-testid') || el.getAttribute('data-testid') || '',
+          text: rawText.replace(/\\s+/g, ' ').slice(0, 400),
+          inNav: Boolean(clickable.closest('nav,aside')),
+        };
+      };
+      const candidates = allElements.map(toCandidate);
+      const mainCandidates = candidates.filter((item) => !item.inNav);
+      const navCandidates = candidates.filter((item) => item.inNav);
+      const visible = (item) => {
+        const rect = item.clickable.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+      const pick = (items) => (items.find(visible) || items[0] || null);
+      const pickWithAttempt = (items) => {
+        if (!items.length) return null;
+        const visibleItems = items.filter(visible);
+        const pool = visibleItems.length > 0 ? visibleItems : items;
+        const index = Math.min(attemptIndex, pool.length - 1);
+        return pool[index] ?? null;
+      };
+      let target = null;
+      if (conversationId) {
+        const byId = (item) =>
+          (item.href && item.href.includes('/c/' + conversationId)) ||
+          (item.conversationId && item.conversationId === conversationId);
+        target = pick(mainCandidates.filter(byId)) || pick(navCandidates.filter(byId));
+      }
+      if (!target && promptNeedles.length > 0) {
+        const byPrompt = (item) => promptNeedles.some((needle) => item.text && item.text.toLowerCase().includes(needle));
+        const sortBySpecificity = (items) =>
+          items
+            .filter(byPrompt)
+            .sort((a, b) => (a.text?.length ?? 0) - (b.text?.length ?? 0));
+        target = pickWithAttempt(sortBySpecificity(mainCandidates)) || pickWithAttempt(sortBySpecificity(navCandidates));
+      }
+      if (!target) {
+        const byHref = (item) => item.href && item.href.includes('/c/');
+        target = pickWithAttempt(mainCandidates.filter(byHref)) || pickWithAttempt(navCandidates.filter(byHref));
+      }
+      if (!target) {
+        const byTestId = (item) => /conversation|history/i.test(item.testId || '');
+        target = pickWithAttempt(mainCandidates.filter(byTestId)) || pickWithAttempt(navCandidates.filter(byTestId));
+      }
+      if (target) {
+        target.clickable.scrollIntoView({ block: 'center' });
+        target.clickable.dispatchEvent(
+          new MouseEvent('click', { bubbles: true, cancelable: true, view: window }),
+        );
+        // Fallback: some project-sidebar items don't navigate on click, force the URL.
+        if (target.href && target.href.includes('/c/')) {
+          const targetUrl = target.href.startsWith('http')
+            ? target.href
+            : new URL(target.href, location.origin).toString();
+          if (targetUrl && targetUrl !== location.href) {
+            location.href = targetUrl;
+          }
+        }
+        return {
+          ok: true,
+          href: target.href || '',
+          count: candidates.length,
+          scope: target.inNav ? 'nav' : 'main',
+        };
+      }
+      return { ok: false, count: candidates.length };
+    })()`,
+        returnByValue: true,
+    });
+    return Boolean(response.result?.value?.ok);
+}
+export async function openConversationFromSidebarWithRetry(Runtime, options, timeoutMs) {
+    const start = Date.now();
+    let attempt = 0;
+    while (Date.now() - start < timeoutMs) {
+        // Retry because project list can hydrate after initial navigation.
+        const opened = await openConversationFromSidebar(Runtime, options, attempt);
+        if (opened) {
+            if (options.promptPreview) {
+                const matched = await waitForPromptPreview(Runtime, options.promptPreview, 10_000);
+                if (matched) {
+                    return true;
+                }
+            }
+            else {
+                return true;
+            }
+        }
+        attempt += 1;
+        await delay(attempt < 5 ? 250 : 500);
+    }
+    return false;
+}
+export async function waitForPromptPreview(Runtime, promptPreview, timeoutMs) {
+    const needleFull = promptPreview.trim().toLowerCase().slice(0, 120);
+    const needleShort = needleFull.replace(/\\s*\\d{4,}\\s*$/, '').trim();
+    const needles = Array.from(new Set([needleFull, needleShort].filter(Boolean)));
+    if (needles.length === 0)
+        return false;
+    const selectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const expression = `(() => {
+    const needles = ${JSON.stringify(needles)};
+    const root =
+      document.querySelector('section[data-testid="screen-threadFlyOut"]') ||
+      document.querySelector('[data-testid="chat-thread"]') ||
+      document.querySelector('main') ||
+      document.querySelector('[role="main"]');
+    if (!root) return false;
+    const userTurns = Array.from(root.querySelectorAll('[data-message-author-role="user"], [data-turn="user"]'));
+    const collectText = (nodes) =>
+      nodes
+        .map((node) => (node.innerText || node.textContent || ''))
+        .join(' ')
+        .toLowerCase();
+    let text = collectText(userTurns);
+    let hasTurns = userTurns.length > 0;
+    if (!text) {
+      const turns = Array.from(root.querySelectorAll(${selectorLiteral}));
+      hasTurns = hasTurns || turns.length > 0;
+      text = collectText(turns);
+    }
+    if (!text) {
+      text = (root.innerText || root.textContent || '').toLowerCase();
+    }
+    return needles.some((needle) => text.includes(needle));
+  })()`;
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+            if (result?.value === true) {
+                return true;
+            }
+        }
+        catch {
+            // ignore
+        }
+        await delay(300);
+    }
+    return false;
+}
+export async function waitForLocationChange(Runtime, timeoutMs) {
+    const start = Date.now();
+    let lastHref = '';
+    while (Date.now() - start < timeoutMs) {
+        const { result } = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
+        const href = typeof result?.value === 'string' ? result.value : '';
+        if (lastHref && href !== lastHref) {
+            return;
+        }
+        lastHref = href;
+        await delay(200);
+    }
+}
+export async function readConversationTurnIndex(Runtime, logger) {
+    const selectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    try {
+        const { result } = await Runtime.evaluate({
+            expression: `document.querySelectorAll(${selectorLiteral}).length`,
+            returnByValue: true,
+        });
+        const raw = typeof result?.value === 'number' ? result.value : Number(result?.value);
+        if (!Number.isFinite(raw)) {
+            throw new Error('Turn count not numeric');
+        }
+        return Math.max(0, Math.floor(raw) - 1);
+    }
+    catch (error) {
+        if (logger?.verbose) {
+            logger(`Failed to read conversation turn index: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return null;
+    }
+}
+function normalizeForComparison(text) {
+    return String(text || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+}
+export function buildPromptEchoMatcher(promptPreview) {
+    const normalizedPrompt = normalizeForComparison(promptPreview ?? '');
+    if (!normalizedPrompt) {
+        return null;
+    }
+    const promptPrefix = normalizedPrompt.length >= 80 ? normalizedPrompt.slice(0, Math.min(200, normalizedPrompt.length)) : '';
+    const minFragment = Math.min(40, normalizedPrompt.length);
+    return {
+        isEcho: (text) => {
+            const normalized = normalizeForComparison(text);
+            if (!normalized)
+                return false;
+            if (normalized === normalizedPrompt)
+                return true;
+            if (promptPrefix.length > 0 && normalized.startsWith(promptPrefix))
+                return true;
+            if (normalized.length >= minFragment && normalizedPrompt.startsWith(normalized)) {
+                return true;
+            }
+            if (normalized.includes('…') || normalized.includes('...')) {
+                const marker = normalized.includes('…') ? '…' : '...';
+                const [prefixRaw, suffixRaw] = normalized.split(marker);
+                const prefix = prefixRaw?.trim() ?? '';
+                const suffix = suffixRaw?.trim() ?? '';
+                if (!prefix && !suffix)
+                    return false;
+                if (prefix && !normalizedPrompt.includes(prefix))
+                    return false;
+                if (suffix && !normalizedPrompt.includes(suffix))
+                    return false;
+                const fragmentLength = prefix.length + suffix.length;
+                return fragmentLength >= minFragment;
+            }
+            return false;
+        },
+    };
+}
+export async function recoverPromptEcho(Runtime, answer, matcher, logger, minTurnIndex, timeoutMs) {
+    if (!matcher || !matcher.isEcho(answer.text)) {
+        return answer;
+    }
+    logger('Detected prompt echo while reattaching; waiting for assistant response...');
+    const deadline = Date.now() + Math.min(timeoutMs, 15_000);
+    let bestText = null;
+    let stableCount = 0;
+    while (Date.now() < deadline) {
+        const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex ?? undefined).catch(() => null);
+        const text = typeof snapshot?.text === 'string' ? snapshot.text.trim() : '';
+        if (!text || matcher.isEcho(text)) {
+            await delay(300);
+            continue;
+        }
+        if (!bestText || text.length > bestText.length) {
+            bestText = text;
+            stableCount = 0;
+        }
+        else if (text === bestText) {
+            stableCount += 1;
+        }
+        if (stableCount >= 2) {
+            break;
+        }
+        await delay(300);
+    }
+    if (bestText) {
+        logger('Recovered assistant response after prompt echo during reattach');
+        return { ...answer, text: bestText };
+    }
+    return answer;
+}
+export function alignPromptEchoPair(answerText, answerMarkdown, matcher, logger, messages) {
+    if (!matcher) {
+        return { answerText, answerMarkdown, textEcho: false, markdownEcho: false, isEcho: false };
+    }
+    let textEcho = matcher.isEcho(answerText);
+    let markdownEcho = matcher.isEcho(answerMarkdown);
+    if (textEcho && !markdownEcho && answerMarkdown) {
+        if (logger && messages?.text) {
+            logger(messages.text);
+        }
+        answerText = answerMarkdown;
+        textEcho = false;
+    }
+    if (markdownEcho && !textEcho && answerText) {
+        if (logger && messages?.markdown) {
+            logger(messages.markdown);
+        }
+        answerMarkdown = answerText;
+        markdownEcho = false;
+    }
+    return {
+        answerText,
+        answerMarkdown,
+        textEcho,
+        markdownEcho,
+        isEcho: textEcho || markdownEcho,
+    };
+}
+export function alignPromptEchoMarkdown(answerText, answerMarkdown, matcher, logger) {
+    const aligned = alignPromptEchoPair(answerText, answerMarkdown, matcher, logger, {
+        text: 'Aligned prompt-echo text to copied markdown during reattach',
+        markdown: 'Aligned prompt-echo markdown to response text during reattach',
+    });
+    return { answerText: aligned.answerText, answerMarkdown: aligned.answerMarkdown };
+}

package/dist/src/browser/sessionRunner.js

@@ -0,0 +1,119 @@
+import chalk from 'chalk';
+import { formatTokenCount } from '../oracle/runUtils.js';
+import { formatFinishLine } from '../oracle/finishLine.js';
+import { runBrowserMode } from '../browserMode.js';
+import { assembleBrowserPrompt } from './prompt.js';
+import { BrowserAutomationError } from '../oracle/errors.js';
+export async function runBrowserSessionExecution({ runOptions, browserConfig, cwd, log }, deps = {}) {
+    const assemblePrompt = deps.assemblePrompt ?? assembleBrowserPrompt;
+    const executeBrowser = deps.executeBrowser ?? runBrowserMode;
+    const promptArtifacts = await assemblePrompt(runOptions, { cwd });
+    if (runOptions.verbose) {
+        log(chalk.dim(`[verbose] Browser config: ${JSON.stringify({
+            ...browserConfig,
+        })}`));
+        log(chalk.dim(`[verbose] Browser prompt length: ${promptArtifacts.composerText.length} chars`));
+        if (promptArtifacts.attachments.length > 0) {
+            const attachmentList = promptArtifacts.attachments.map((attachment) => attachment.displayPath).join(', ');
+            log(chalk.dim(`[verbose] Browser attachments: ${attachmentList}`));
+            if (promptArtifacts.bundled) {
+                log(chalk.yellow(`[browser] Bundled ${promptArtifacts.bundled.originalCount} files into ${promptArtifacts.bundled.bundlePath}.`));
+            }
+        }
+        else if (runOptions.file && runOptions.file.length > 0 && promptArtifacts.attachmentMode === 'inline') {
+            log(chalk.dim('[verbose] Browser will paste file contents inline (no uploads).'));
+        }
+    }
+    if (promptArtifacts.bundled) {
+        log(chalk.dim(`Packed ${promptArtifacts.bundled.originalCount} files into 1 bundle (contents counted in token estimate).`));
+    }
+    const headerLine = `Launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens.`;
+    const automationLogger = ((message) => {
+        if (typeof message !== 'string')
+            return;
+        const shouldAlwaysPrint = message.startsWith('[browser] ') && /fallback|retry/i.test(message);
+        if (!runOptions.verbose && !shouldAlwaysPrint)
+            return;
+        log(message);
+    });
+    automationLogger.verbose = Boolean(runOptions.verbose);
+    automationLogger.sessionLog = runOptions.verbose ? log : (() => { });
+    log(headerLine);
+    log(chalk.dim('This run can take up to an hour (usually ~10 minutes).'));
+    if (runOptions.verbose) {
+        log(chalk.dim('Chrome automation does not stream output; this may take a minute...'));
+    }
+    const persistRuntimeHint = deps.persistRuntimeHint ?? (() => { });
+    let browserResult;
+    try {
+        browserResult = await executeBrowser({
+            prompt: promptArtifacts.composerText,
+            attachments: promptArtifacts.attachments,
+            fallbackSubmission: promptArtifacts.fallback
+                ? { prompt: promptArtifacts.fallback.composerText, attachments: promptArtifacts.fallback.attachments }
+                : undefined,
+            config: browserConfig,
+            log: automationLogger,
+            heartbeatIntervalMs: runOptions.heartbeatIntervalMs,
+            verbose: runOptions.verbose,
+            runtimeHintCb: async (runtime) => {
+                await persistRuntimeHint({ ...runtime, controllerPid: runtime.controllerPid ?? process.pid });
+            },
+        });
+    }
+    catch (error) {
+        if (error instanceof BrowserAutomationError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : 'Browser automation failed.';
+        throw new BrowserAutomationError(message, { stage: 'execute-browser' }, error);
+    }
+    if (!runOptions.silent) {
+        log(chalk.bold('Answer:'));
+        log(browserResult.answerMarkdown || browserResult.answerText || chalk.dim('(no text output)'));
+        log('');
+    }
+    const answerText = browserResult.answerMarkdown || browserResult.answerText || '';
+    const usage = {
+        inputTokens: promptArtifacts.estimatedInputTokens,
+        outputTokens: browserResult.answerTokens,
+        reasoningTokens: 0,
+        totalTokens: promptArtifacts.estimatedInputTokens + browserResult.answerTokens,
+    };
+    const tokensDisplay = [
+        usage.inputTokens,
+        usage.outputTokens,
+        usage.reasoningTokens,
+        usage.totalTokens,
+    ]
+        .map((value) => formatTokenCount(value))
+        .join('/');
+    const tokensPart = (() => {
+        const parts = tokensDisplay.split('/');
+        if (parts.length !== 4)
+            return tokensDisplay;
+        return `↑${parts[0]} ↓${parts[1]} ↻${parts[2]} Δ${parts[3]}`;
+    })();
+    const { line1, line2 } = formatFinishLine({
+        elapsedMs: browserResult.tookMs,
+        model: `${runOptions.model}[browser]`,
+        tokensPart,
+        detailParts: [runOptions.file && runOptions.file.length > 0 ? `files=${runOptions.file.length}` : null],
+    });
+    log(chalk.blue(line1));
+    if (line2) {
+        log(chalk.dim(line2));
+    }
+    return {
+        usage,
+        elapsedMs: browserResult.tookMs,
+        runtime: {
+            chromePid: browserResult.chromePid,
+            chromePort: browserResult.chromePort,
+            chromeHost: browserResult.chromeHost,
+            userDataDir: browserResult.userDataDir,
+            controllerPid: browserResult.controllerPid ?? process.pid,
+        },
+        answerText,
+    };
+}

package/dist/src/browser/types.js

@@ -0,0 +1 @@
+export {};