@indykish/oracle 0.9.0

package/dist/src/browser/modelStrategy.js

@@ -0,0 +1,13 @@
+export function normalizeBrowserModelStrategy(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'select' || normalized === 'current' || normalized === 'ignore') {
+        return normalized;
+    }
+    throw new Error(`Invalid browser model strategy: "${value}". Expected "select", "current", or "ignore".`);
+}

package/dist/src/browser/pageActions.js

@@ -0,0 +1,5 @@
+export { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, } from './actions/navigation.js';
+export { ensureModelSelection } from './actions/modelSelection.js';
+export { submitPrompt, clearPromptComposer } from './actions/promptComposer.js';
+export { clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, } from './actions/attachments.js';
+export { waitForAssistantResponse, readAssistantSnapshot, captureAssistantMarkdown, buildAssistantExtractorForTest, buildConversationDebugExpressionForTest, buildMarkdownFallbackExtractorForTest, buildCopyExpressionForTest, } 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}).` };
+}

package/dist/src/browser/profileState.js

@@ -0,0 +1,280 @@
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { delay } from './utils.js';
+const DEVTOOLS_ACTIVE_PORT_FILENAME = 'DevToolsActivePort';
+const DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS = [
+    DEVTOOLS_ACTIVE_PORT_FILENAME,
+    path.join('Default', DEVTOOLS_ACTIVE_PORT_FILENAME),
+];
+const CHROME_PID_FILENAME = 'chrome.pid';
+const ORACLE_PROFILE_LOCK_FILENAME = 'oracle-automation.lock';
+const execFileAsync = promisify(execFile);
+export function getDevToolsActivePortPaths(userDataDir) {
+    return DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS.map((relative) => path.join(userDataDir, relative));
+}
+export async function readDevToolsPort(userDataDir) {
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            const raw = await readFile(candidate, 'utf8');
+            const firstLine = raw.split(/\r?\n/u)[0]?.trim();
+            const port = Number.parseInt(firstLine ?? '', 10);
+            if (Number.isFinite(port)) {
+                return port;
+            }
+        }
+        catch {
+            // ignore missing/unreadable candidates
+        }
+    }
+    return null;
+}
+export async function writeDevToolsActivePort(userDataDir, port) {
+    const contents = `${port}\n/devtools/browser`;
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            await mkdir(path.dirname(candidate), { recursive: true });
+            await writeFile(candidate, contents, 'utf8');
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+export async function readChromePid(userDataDir) {
+    const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
+    try {
+        const raw = (await readFile(pidPath, 'utf8')).trim();
+        const pid = Number.parseInt(raw, 10);
+        if (!Number.isFinite(pid) || pid <= 0) {
+            return null;
+        }
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeChromePid(userDataDir, pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return;
+    const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
+    try {
+        await mkdir(path.dirname(pidPath), { recursive: true });
+        await writeFile(pidPath, `${Math.trunc(pid)}\n`, 'utf8');
+    }
+    catch {
+        // best effort
+    }
+}
+export function isProcessAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM means "exists but no permission"; treat as alive.
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+function parseProfileRunLock(payload) {
+    if (!payload)
+        return null;
+    try {
+        const parsed = JSON.parse(payload);
+        if (!Number.isFinite(parsed.pid) || parsed.pid <= 0)
+            return null;
+        if (!parsed.lockId || typeof parsed.lockId !== 'string')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function acquireProfileRunLock(userDataDir, options) {
+    const timeoutMs = options.timeoutMs;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return null;
+    }
+    const pollMs = typeof options.pollMs === 'number' && Number.isFinite(options.pollMs) && options.pollMs > 0
+        ? options.pollMs
+        : 1000;
+    const lockPath = path.join(userDataDir, ORACLE_PROFILE_LOCK_FILENAME);
+    const lockId = randomUUID();
+    const startedAt = Date.now();
+    let warned = false;
+    for (;;) {
+        try {
+            const payload = {
+                pid: process.pid,
+                lockId,
+                createdAt: new Date().toISOString(),
+                sessionId: options.sessionId,
+            };
+            await mkdir(path.dirname(lockPath), { recursive: true });
+            await writeFile(lockPath, JSON.stringify(payload), { encoding: 'utf8', flag: 'wx' });
+            options.logger?.(`Acquired Oracle profile lock at ${lockPath}`);
+            return {
+                path: lockPath,
+                lockId,
+                release: async () => releaseProfileRunLock(lockPath, lockId, options.logger),
+            };
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'EEXIST') {
+                throw error;
+            }
+            let existing = parseProfileRunLock(await readFile(lockPath, 'utf8').catch(() => null));
+            if (!existing) {
+                // Likely partial write / corruption; re-read once, then delete (user preference: delete unreadable lockfiles).
+                await delay(200);
+                existing = parseProfileRunLock(await readFile(lockPath, 'utf8').catch(() => null));
+                if (!existing) {
+                    options.logger?.('Oracle profile lock unreadable; deleting lockfile.');
+                    await rm(lockPath, { force: true }).catch(() => undefined);
+                    continue;
+                }
+            }
+            if (!existing || !isProcessAlive(existing.pid)) {
+                await rm(lockPath, { force: true }).catch(() => undefined);
+                continue;
+            }
+            if (!warned) {
+                const waited = Math.round(timeoutMs / 1000);
+                options.logger?.(`Oracle profile lock held by pid ${existing.pid}; waiting up to ${waited}s.`);
+                warned = true;
+            }
+            const elapsed = Date.now() - startedAt;
+            if (elapsed >= timeoutMs) {
+                throw new Error(`Oracle profile lock still held by pid ${existing.pid} after ${Math.round(elapsed / 1000)}s`);
+            }
+            await delay(Math.min(pollMs, timeoutMs - elapsed));
+        }
+    }
+}
+export async function releaseProfileRunLock(lockPath, lockId, logger) {
+    try {
+        const existing = parseProfileRunLock(await readFile(lockPath, 'utf8').catch(() => null));
+        if (!existing || existing.lockId !== lockId) {
+            return;
+        }
+        await rm(lockPath, { force: true });
+        logger?.(`Released Oracle profile lock ${lockPath}`);
+    }
+    catch {
+        // best effort
+    }
+}
+export async function verifyDevToolsReachable({ port, host = '127.0.0.1', attempts = 3, timeoutMs = 3000, }) {
+    const versionUrl = `http://${host}:${port}/json/version`;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            const response = await fetch(versionUrl, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            if (attempt < attempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    return { ok: false, error: 'unreachable' };
+}
+export async function shouldCleanupManualLoginProfileState(userDataDir, logger, options = {}) {
+    if (!options.connectionClosedUnexpectedly) {
+        return true;
+    }
+    const port = await readDevToolsPort(userDataDir);
+    if (!port) {
+        return true;
+    }
+    const probe = await (options.probe ?? verifyDevToolsReachable)({ port, host: options.host });
+    if (probe.ok) {
+        logger?.(`DevTools port ${port} still reachable; preserving manual-login profile state`);
+        return false;
+    }
+    logger?.(`DevTools port ${port} unreachable (${probe.error}); clearing stale profile state`);
+    return true;
+}
+export async function cleanupStaleProfileState(userDataDir, logger, options = {}) {
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            await rm(candidate, { force: true });
+            logger?.(`Removed stale DevToolsActivePort: ${candidate}`);
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+    const lockRemovalMode = options.lockRemovalMode ?? 'never';
+    if (lockRemovalMode === 'never') {
+        return;
+    }
+    const pid = await readChromePid(userDataDir);
+    if (!pid) {
+        return;
+    }
+    if (isProcessAlive(pid)) {
+        logger?.(`Chrome pid ${pid} still alive; skipping profile lock cleanup`);
+        return;
+    }
+    // Extra safety: if Chrome is running with this profile (but with a different PID, e.g. user relaunched
+    // without remote debugging), never delete lock files.
+    if (await isChromeUsingUserDataDir(userDataDir)) {
+        logger?.('Detected running Chrome using this profile; skipping profile lock cleanup');
+        return;
+    }
+    const lockFiles = [
+        path.join(userDataDir, 'lockfile'),
+        path.join(userDataDir, 'SingletonLock'),
+        path.join(userDataDir, 'SingletonSocket'),
+        path.join(userDataDir, 'SingletonCookie'),
+    ];
+    for (const lock of lockFiles) {
+        await rm(lock, { force: true }).catch(() => undefined);
+    }
+    logger?.('Cleaned up stale Chrome profile locks');
+}
+async function isChromeUsingUserDataDir(userDataDir) {
+    if (process.platform === 'win32') {
+        // On Windows, lockfiles are typically held open and removal should fail anyway; avoid expensive process scans.
+        return false;
+    }
+    try {
+        const { stdout } = await execFileAsync('ps', ['-ax', '-o', 'command='], { maxBuffer: 10 * 1024 * 1024 });
+        const lines = String(stdout ?? '').split('\n');
+        const needle = userDataDir;
+        for (const line of lines) {
+            if (!line)
+                continue;
+            const lower = line.toLowerCase();
+            if (!lower.includes('chrome') && !lower.includes('chromium'))
+                continue;
+            if (line.includes(needle) && lower.includes('user-data-dir')) {
+                return true;
+            }
+        }
+    }
+    catch {
+        // best effort
+    }
+    return false;
+}

package/dist/src/browser/prompt.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { readFiles, createFileSections, MODEL_CONFIGS, TOKENIZER_OPTIONS, formatFileSection, } from '../oracle.js';
+import { isKnownModel } from '../oracle/modelResolver.js';
+import { buildPromptMarkdown } from '../oracle/promptAssembly.js';
+import { buildAttachmentPlan } from './policies.js';
+const DEFAULT_BROWSER_INLINE_CHAR_BUDGET = 60_000;
+const MEDIA_EXTENSIONS = new Set([
+    '.mp4', '.mov', '.avi', '.mkv', '.webm', '.m4v',
+    '.mp3', '.wav', '.aac', '.flac', '.ogg', '.m4a',
+    '.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.svg', '.heic', '.heif',
+    '.pdf',
+]);
+export function isMediaFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MEDIA_EXTENSIONS.has(ext);
+}
+export async function assembleBrowserPrompt(runOptions, deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const readFilesFn = deps.readFilesImpl ?? readFiles;
+    const allFilePaths = runOptions.file ?? [];
+    const textFilePaths = allFilePaths.filter((f) => !isMediaFile(f));
+    const mediaFilePaths = allFilePaths.filter((f) => isMediaFile(f));
+    const mediaAttachments = await Promise.all(mediaFilePaths.map(async (filePath) => {
+        const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+        const stats = await fs.stat(resolvedPath);
+        return {
+            path: resolvedPath,
+            displayPath: path.relative(cwd, resolvedPath) || path.basename(resolvedPath),
+            sizeBytes: stats.size,
+        };
+    }));
+    const files = await readFilesFn(textFilePaths, { cwd });
+    const basePrompt = (runOptions.prompt ?? '').trim();
+    const userPrompt = basePrompt;
+    const systemPrompt = runOptions.system?.trim() || '';
+    const sections = createFileSections(files, cwd);
+    const markdown = buildPromptMarkdown(systemPrompt, userPrompt, sections);
+    const attachmentsPolicy = runOptions.browserInlineFiles
+        ? 'never'
+        : runOptions.browserAttachments ?? 'auto';
+    const bundleRequested = Boolean(runOptions.browserBundleFiles);
+    const inlinePlan = buildAttachmentPlan(sections, { inlineFiles: true, bundleRequested });
+    const uploadPlan = buildAttachmentPlan(sections, { inlineFiles: false, bundleRequested });
+    const baseComposerSections = [];
+    if (systemPrompt)
+        baseComposerSections.push(systemPrompt);
+    if (userPrompt)
+        baseComposerSections.push(userPrompt);
+    const inlineComposerText = [...baseComposerSections, inlinePlan.inlineBlock].filter(Boolean).join('\n\n').trim();
+    const selectedPlan = attachmentsPolicy === 'always'
+        ? uploadPlan
+        : attachmentsPolicy === 'never'
+            ? inlinePlan
+            : inlineComposerText.length <= DEFAULT_BROWSER_INLINE_CHAR_BUDGET || sections.length === 0
+                ? inlinePlan
+                : uploadPlan;
+    const composerText = (selectedPlan.inlineBlock
+        ? [...baseComposerSections, selectedPlan.inlineBlock]
+        : baseComposerSections)
+        .filter(Boolean)
+        .join('\n\n')
+        .trim();
+    const attachments = [...selectedPlan.attachments, ...mediaAttachments];
+    const shouldBundle = selectedPlan.shouldBundle;
+    let bundleText = null;
+    let bundled = null;
+    if (shouldBundle) {
+        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(formatFileSection(section.displayPath, section.content).trimEnd());
+            bundleLines.push('');
+        });
+        bundleText = `${bundleLines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd()}\n`;
+        await fs.writeFile(bundlePath, bundleText, 'utf8');
+        attachments.length = 0;
+        attachments.push({
+            path: bundlePath,
+            displayPath: bundlePath,
+            sizeBytes: Buffer.byteLength(bundleText, 'utf8'),
+        });
+        attachments.push(...mediaAttachments);
+        bundled = { originalCount: sections.length, bundlePath };
+    }
+    const inlineFileCount = selectedPlan.inlineFileCount;
+    const modelConfig = isKnownModel(runOptions.model) ? MODEL_CONFIGS[runOptions.model] : MODEL_CONFIGS['gpt-5.1'];
+    const tokenizer = deps.tokenizeImpl ?? modelConfig.tokenizer;
+    const tokenizerUserContent = inlineFileCount > 0 && selectedPlan.inlineBlock
+        ? [userPrompt, selectedPlan.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);
+    let estimatedInputTokens = tokenizer(tokenizerMessages.length > 0
+        ? tokenizerMessages
+        : [{ role: 'user', content: '' }], TOKENIZER_OPTIONS);
+    const tokenEstimateIncludesInlineFiles = inlineFileCount > 0 && Boolean(selectedPlan.inlineBlock);
+    if (!tokenEstimateIncludesInlineFiles && sections.length > 0) {
+        const attachmentText = bundleText ??
+            sections
+                .map((section) => formatFileSection(section.displayPath, section.content).trimEnd())
+                .join('\n\n');
+        const attachmentTokens = tokenizer([{ role: 'user', content: attachmentText }], TOKENIZER_OPTIONS);
+        estimatedInputTokens += attachmentTokens;
+    }
+    let fallback = null;
+    if (attachmentsPolicy === 'auto' && selectedPlan.mode === 'inline' && sections.length > 0) {
+        const fallbackComposerText = baseComposerSections.join('\n\n').trim();
+        const fallbackAttachments = [...uploadPlan.attachments, ...mediaAttachments];
+        let fallbackBundled = null;
+        if (uploadPlan.shouldBundle) {
+            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(formatFileSection(section.displayPath, section.content).trimEnd());
+                bundleLines.push('');
+            });
+            const fallbackBundleText = `${bundleLines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd()}\n`;
+            await fs.writeFile(bundlePath, fallbackBundleText, 'utf8');
+            fallbackAttachments.length = 0;
+            fallbackAttachments.push({
+                path: bundlePath,
+                displayPath: bundlePath,
+                sizeBytes: Buffer.byteLength(fallbackBundleText, 'utf8'),
+            });
+            fallbackAttachments.push(...mediaAttachments);
+            fallbackBundled = { originalCount: sections.length, bundlePath };
+        }
+        fallback = {
+            composerText: fallbackComposerText,
+            attachments: fallbackAttachments,
+            bundled: fallbackBundled,
+        };
+    }
+    return {
+        markdown,
+        composerText,
+        estimatedInputTokens,
+        attachments,
+        inlineFileCount,
+        tokenEstimateIncludesInlineFiles,
+        attachmentsPolicy,
+        attachmentMode: selectedPlan.mode,
+        fallback,
+        bundled,
+    };
+}

package/dist/src/browser/promptSummary.js

@@ -0,0 +1,20 @@
+import { formatBytes } from './utils.js';
+export function buildTokenEstimateSuffix(artifacts) {
+    if (artifacts.tokenEstimateIncludesInlineFiles && artifacts.inlineFileCount > 0) {
+        const count = artifacts.inlineFileCount;
+        const plural = count === 1 ? '' : 's';
+        return ` (includes ${count} inline file${plural})`;
+    }
+    if (artifacts.attachments.length > 0) {
+        const count = artifacts.attachments.length;
+        const plural = count === 1 ? '' : 's';
+        return ` (prompt only; ${count} attachment${plural} excluded)`;
+    }
+    return '';
+}
+export function formatAttachmentLabel(attachment) {
+    if (typeof attachment.sizeBytes !== 'number' || Number.isNaN(attachment.sizeBytes)) {
+        return attachment.displayPath;
+    }
+    return `${attachment.displayPath} (${formatBytes(attachment.sizeBytes)})`;
+}