@steipete/oracle 0.4.0

package/dist/src/browser/prompt.js

@@ -0,0 +1,82 @@
+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 { buildPromptMarkdown } from '../oracle/promptAssembly.js';
+import { buildAttachmentPlan } from './policies.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() || '';
+    const sections = createFileSections(files, cwd);
+    const markdown = buildPromptMarkdown(systemPrompt, userPrompt, sections);
+    const inlineFiles = Boolean(runOptions.browserInlineFiles);
+    const composerSections = [];
+    if (systemPrompt)
+        composerSections.push(systemPrompt);
+    if (userPrompt)
+        composerSections.push(userPrompt);
+    const attachmentPlan = buildAttachmentPlan(sections, {
+        inlineFiles,
+        bundleRequested: Boolean(runOptions.browserBundleFiles),
+    });
+    if (attachmentPlan.inlineBlock) {
+        composerSections.push(attachmentPlan.inlineBlock);
+    }
+    const composerText = composerSections.join('\n\n').trim();
+    const attachments = attachmentPlan.attachments.slice();
+    const shouldBundle = attachmentPlan.shouldBundle;
+    let bundleText = 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'),
+        });
+    }
+    const inlineFileCount = attachmentPlan.inlineFileCount;
+    const tokenizer = MODEL_CONFIGS[runOptions.model].tokenizer;
+    const tokenizerUserContent = inlineFileCount > 0 && attachmentPlan.inlineBlock
+        ? [userPrompt, attachmentPlan.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(attachmentPlan.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;
+    }
+    return {
+        markdown,
+        composerText,
+        estimatedInputTokens,
+        attachments,
+        inlineFileCount,
+        tokenEstimateIncludesInlineFiles,
+        bundled: shouldBundle && attachments.length === 1 && attachments[0]?.displayPath
+            ? { originalCount: sections.length, bundlePath: attachments[0].displayPath }
+            : null,
+    };
+}

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

package/dist/src/browser/sessionRunner.js

@@ -0,0 +1,96 @@
+import chalk from 'chalk';
+import { formatElapsed } from '../oracle.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 = {}) {
+    if (runOptions.model.startsWith('gemini')) {
+        throw new BrowserAutomationError('Gemini models are not available in browser mode. Re-run with --engine api.', {
+            stage: 'preflight',
+        });
+    }
+    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 && runOptions.browserInlineFiles) {
+            log(chalk.dim('[verbose] Browser inline file fallback enabled (pasting file contents).'));
+        }
+    }
+    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 (!runOptions.verbose)
+            return;
+        if (typeof message === 'string') {
+            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...'));
+    }
+    let browserResult;
+    try {
+        browserResult = await executeBrowser({
+            prompt: promptArtifacts.composerText,
+            attachments: promptArtifacts.attachments,
+            config: browserConfig,
+            log: automationLogger,
+            heartbeatIntervalMs: runOptions.heartbeatIntervalMs,
+            verbose: runOptions.verbose,
+        });
+    }
+    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}`;
+    const tokensLabel = runOptions.verbose ? 'tokens (input/output/reasoning/total)' : 'tok(i/o/r/t)';
+    const statsParts = [`${runOptions.model}[browser]`, `${tokensLabel}=${tokensDisplay}`];
+    if (runOptions.file && runOptions.file.length > 0) {
+        statsParts.push(`files=${runOptions.file.length}`);
+    }
+    log(chalk.blue(`Finished in ${formatElapsed(browserResult.tookMs)} (${statsParts.join(' | ')})`));
+    return {
+        usage,
+        elapsedMs: browserResult.tookMs,
+        runtime: {
+            chromePid: browserResult.chromePid,
+            chromePort: browserResult.chromePort,
+            userDataDir: browserResult.userDataDir,
+        },
+        answerText,
+    };
+}

package/dist/src/browser/types.js

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

package/dist/src/browser/utils.js

@@ -0,0 +1,112 @@
+export function parseDuration(input, fallback) {
+    if (!input) {
+        return fallback;
+    }
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return fallback;
+    }
+    const lowercase = trimmed.toLowerCase();
+    if (/^[0-9]+$/.test(lowercase)) {
+        return Number(lowercase);
+    }
+    const normalized = lowercase.replace(/\s+/g, '');
+    const singleMatch = /^([0-9]+)(ms|s|m|h)$/i.exec(normalized);
+    if (singleMatch && singleMatch[0].length === normalized.length) {
+        const value = Number(singleMatch[1]);
+        return convertUnit(value, singleMatch[2]);
+    }
+    const multiDuration = /([0-9]+)(ms|h|m|s)/g;
+    let total = 0;
+    let lastIndex = 0;
+    let match = multiDuration.exec(normalized);
+    while (match !== null) {
+        total += convertUnit(Number(match[1]), match[2]);
+        lastIndex = multiDuration.lastIndex;
+        match = multiDuration.exec(normalized);
+    }
+    if (total > 0 && lastIndex === normalized.length) {
+        return total;
+    }
+    return fallback;
+}
+function convertUnit(value, unitRaw) {
+    const unit = unitRaw?.toLowerCase();
+    switch (unit) {
+        case 'ms':
+            return value;
+        case 's':
+            return value * 1000;
+        case 'm':
+            return value * 60_000;
+        case 'h':
+            return value * 3_600_000;
+        default:
+            return value;
+    }
+}
+export function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function estimateTokenCount(text) {
+    if (!text) {
+        return 0;
+    }
+    const words = text.trim().split(/\s+/).filter(Boolean);
+    const estimate = Math.max(words.length * 0.75, text.length / 4);
+    return Math.max(1, Math.round(estimate));
+}
+export async function withRetries(task, options = {}) {
+    const { retries = 2, delayMs = 250, onRetry } = options;
+    let attempt = 0;
+    while (attempt <= retries) {
+        try {
+            return await task();
+        }
+        catch (error) {
+            if (attempt === retries) {
+                throw error;
+            }
+            attempt += 1;
+            onRetry?.(attempt, error);
+            await delay(delayMs * attempt);
+        }
+    }
+    throw new Error('withRetries exhausted without result');
+}
+export function formatBytes(size) {
+    if (!Number.isFinite(size) || size < 0) {
+        return 'n/a';
+    }
+    if (size < 1024) {
+        return `${size} B`;
+    }
+    if (size < 1024 * 1024) {
+        return `${(size / 1024).toFixed(1)} KB`;
+    }
+    return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Normalizes a ChatGPT URL, ensuring it is absolute, uses http/https, and trims whitespace.
+ * Falls back to the provided default when input is empty/undefined.
+ */
+export function normalizeChatgptUrl(raw, fallback) {
+    const candidate = raw?.trim();
+    if (!candidate) {
+        return fallback;
+    }
+    const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(candidate);
+    const withScheme = hasScheme ? candidate : `https://${candidate}`;
+    let parsed;
+    try {
+        parsed = new URL(withScheme);
+    }
+    catch {
+        throw new Error(`Invalid ChatGPT URL: "${raw}". Provide an absolute http(s) URL.`);
+    }
+    if (!/^https?:$/i.test(parsed.protocol)) {
+        throw new Error(`Invalid ChatGPT URL protocol: "${parsed.protocol}". Use http or https.`);
+    }
+    // Preserve user-provided path/query; URL#toString will normalize trailing slashes appropriately.
+    return parsed.toString();
+}

package/dist/src/browser/windowsCookies.js

@@ -0,0 +1,218 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import { existsSync, promises as fsp } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import sqlite3 from 'sqlite3';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+let cachedUnprotect = null;
+function getUnprotectData() {
+    if (cachedUnprotect) {
+        return cachedUnprotect;
+    }
+    try {
+        // win-dpapi is CommonJS; require it explicitly and support both named/default shapes.
+        const dpapiModule = createRequire(import.meta.url)('win-dpapi');
+        const unprotect = dpapiModule?.Dpapi?.unprotectData ??
+            dpapiModule?.default?.unprotectData ??
+            ((_) => {
+                throw new Error('win-dpapi unprotectData not available');
+            });
+        cachedUnprotect = unprotect;
+        return unprotect;
+    }
+    catch (error) {
+        if (process.platform !== 'win32') {
+            // On macOS/Linux we don't need DPAPI; return a function that makes misuse obvious.
+            cachedUnprotect = () => {
+                throw new Error('win-dpapi is unavailable on non-Windows platforms');
+            };
+            return cachedUnprotect;
+        }
+        throw error;
+    }
+}
+export async function loadWindowsCookies(dbPath, filterNames) {
+    if (process.platform !== 'win32') {
+        throw new Error('loadWindowsCookies is only supported on Windows');
+    }
+    const localStatePath = await locateLocalState(dbPath);
+    const cookiesCopy = await copyLockedFile(dbPath, 'Cookies'); // name the copy exactly "Cookies"
+    const cookiesDirForFallback = await ensureCookiesDirForFallback(cookiesCopy);
+    const localStateCopy = await copyLockedFile(localStatePath, 'Local State');
+    const aesKey = await extractWindowsAesKey(localStateCopy);
+    const rows = await readChromeCookiesDb(cookiesCopy, filterNames);
+    const cookies = [];
+    for (const row of rows) {
+        const enc = row.encrypted_value && row.encrypted_value.length > 0 ? row.encrypted_value : Buffer.from(row.value ?? '', 'utf8');
+        const decrypted = enc.length > 0 ? decryptCookie(enc, aesKey) : '';
+        cookies.push({
+            name: row.name,
+            value: decrypted,
+            domain: row.host_key?.startsWith('.') ? row.host_key.slice(1) : row.host_key,
+            path: row.path ?? '/',
+            expires: normalizeExpiration(row.expires_utc),
+            secure: Boolean(row.is_secure),
+            httpOnly: Boolean(row.is_httponly),
+        });
+    }
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] windows decrypt decoded ${cookies.length} cookies from ${cookiesCopy} (fallback dir ${cookiesDirForFallback})`);
+    }
+    return cookies.filter((c) => c.value);
+}
+function decryptCookie(value, aesKey) {
+    const prefix = value.slice(0, 3).toString();
+    if (prefix === 'v10' || prefix === 'v11') {
+        const iv = value.slice(3, 15);
+        const tag = value.slice(value.length - 16);
+        const data = value.slice(15, value.length - 16);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', aesKey, iv);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+        return decrypted.toString('utf8');
+    }
+    const unprotectData = getUnprotectData();
+    const unprotected = unprotectData(value, undefined, 'CurrentUser');
+    return Buffer.from(unprotected).toString('utf8');
+}
+async function locateLocalState(dbPath) {
+    // Prefer sibling Local State near the profile path; fall back to default location.
+    const guess = path.resolve(path.join(path.dirname(dbPath), '..', 'Local State'));
+    if (existsSync(guess))
+        return guess;
+    const localState = path.join(os.homedir(), 'AppData', 'Local', 'Google', 'Chrome', 'User Data', 'Local State');
+    if (existsSync(localState))
+        return localState;
+    throw new Error('Chrome Local State not found for AES key');
+}
+async function extractWindowsAesKey(localStatePath) {
+    const raw = await fs.readFile(localStatePath, 'utf8');
+    const state = JSON.parse(raw);
+    const encKeyB64 = state?.os_crypt?.encrypted_key;
+    if (!encKeyB64)
+        throw new Error('encrypted_key missing in Local State');
+    const encKey = Buffer.from(encKeyB64, 'base64');
+    const dpapiBlob = encKey.slice(5); // strip "DPAPI"
+    const unprotectData = getUnprotectData();
+    const unprotected = unprotectData(dpapiBlob, undefined, 'CurrentUser');
+    return Buffer.from(unprotected);
+}
+async function readChromeCookiesDb(dbPath, filterNames) {
+    const db = await openSqlite(dbPath);
+    const placeholders = filterNames && filterNames.size > 0 ? `AND name IN (${Array.from(filterNames).map(() => '?').join(',')})` : '';
+    const params = filterNames ? Array.from(filterNames) : [];
+    const sql = `SELECT name,value,encrypted_value,host_key,path,expires_utc,is_secure,is_httponly FROM cookies WHERE host_key LIKE '%chatgpt.com%' ${placeholders}`;
+    try {
+        return await allSqlite(db, sql, params);
+    }
+    finally {
+        db.close();
+    }
+}
+function openSqlite(dbPath) {
+    return new Promise((resolve, reject) => {
+        const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve(db);
+        });
+    });
+}
+async function copyLockedFile(sourcePath, targetName) {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookie-'));
+    const tempPath = targetName ? path.join(tempDir, targetName) : path.join(tempDir, path.basename(sourcePath));
+    const psScript = `
+$src = '${sourcePath.replace(/'/g, "''")}'
+$dst = '${tempPath.replace(/'/g, "''")}'
+try {
+  $fs = [System.IO.File]::Open($src, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::ReadWrite)
+  $bytes = New-Object byte[] $fs.Length
+  $null = $fs.Read($bytes, 0, $fs.Length)
+  $fs.Close()
+  [System.IO.File]::WriteAllBytes($dst, $bytes)
+  exit 0
+} catch {
+  exit 1
+}
+`;
+    const encoded = Buffer.from(psScript, 'utf16le').toString('base64');
+    const result = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded], {
+        timeout: 15000,
+        encoding: 'utf8',
+    });
+    if (result.status !== 0) {
+        // Fallback: best-effort normal copy
+        await fs.copyFile(sourcePath, tempPath);
+    }
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] copied locked file ${sourcePath} -> ${tempPath}`);
+    }
+    return tempPath;
+}
+// Create a directory containing a file named "Cookies" for chrome-cookies-secure fallback
+export async function ensureCookiesDirForFallback(cookieFile) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-secure-'));
+    const target = path.join(dir, 'Cookies');
+    await fs.copyFile(cookieFile, target);
+    return dir;
+}
+function allSqlite(db, sql, params) {
+    return new Promise((resolve, reject) => {
+        db.all(sql, params, (err, rows) => {
+            if (err)
+                reject(err);
+            else
+                resolve((rows ?? []));
+        });
+    });
+}
+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);
+}
+export async function materializeCookieFile(sourcePath) {
+    if (process.platform !== 'win32')
+        return sourcePath;
+    const resolved = await resolveDirectoryCandidate(sourcePath);
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-'));
+    const tempPath = path.join(tempDir, 'Cookies');
+    await fs.copyFile(resolved, tempPath);
+    return tempPath;
+}
+async function resolveDirectoryCandidate(inputPath) {
+    const stat = await fs.stat(inputPath).catch(() => null);
+    if (!stat?.isDirectory())
+        return inputPath;
+    const network = path.join(inputPath, 'Network', 'Cookies');
+    const direct = path.join(inputPath, 'Cookies');
+    if (await fileExists(network))
+        return network;
+    if (await fileExists(direct))
+        return direct;
+    return inputPath;
+}
+async function fileExists(candidate) {
+    try {
+        const stat = await fsp.stat(candidate);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/browserMode.js

@@ -0,0 +1 @@
+export { runBrowserMode, CHATGPT_URL, DEFAULT_MODEL_TARGET, parseDuration, normalizeChatgptUrl, } from './browser/index.js';