@steipete/oracle 0.4.5 → 0.5.1

package/dist/src/browser/profileSync.js

@@ -0,0 +1,141 @@
+import { mkdir, rm, cp as copyDir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { defaultProfileRoot, expandPath, looksLikePath } from './chromeCookies.js';
+const DIR_EXCLUDES = [
+    'Cache',
+    'Code Cache',
+    'GPUCache',
+    'Service Worker',
+    'Crashpad',
+    'BrowserMetrics*',
+    'GrShaderCache',
+    'ShaderCache',
+    'OptimizationGuide',
+];
+const FILE_EXCLUDES = [
+    'SingletonLock',
+    'SingletonSocket',
+    'SingletonCookie',
+    '*.lock',
+    'lockfile',
+    'Lock',
+    '*.tmp',
+    'DevToolsActivePort',
+    path.join('Default', 'DevToolsActivePort'),
+    path.join('Sessions', '*'),
+    'Current Session',
+    'Current Tabs',
+    'Last Session',
+    'Last Tabs',
+];
+export async function syncChromeProfile(options) {
+    const { targetDir } = options;
+    await mkdir(targetDir, { recursive: true });
+    const { sourceDir, profileName } = await resolveProfileSource(options.profile, options.explicitPath);
+    const logger = options.logger;
+    if (!existsSync(sourceDir)) {
+        throw new Error(`Chrome profile not found at ${sourceDir}. Log in once in Chrome, then retry.`);
+    }
+    // Clean any stale DevTools ports/locks in the target before copying.
+    await rm(targetDir, { recursive: true, force: true }).catch(() => undefined);
+    await mkdir(targetDir, { recursive: true });
+    const result = process.platform === 'win32'
+        ? await copyWithRobocopy(sourceDir, targetDir, logger)
+        : await copyWithRsync(sourceDir, targetDir, logger);
+    // Remove lock files in the copied profile to avoid "already running" errors.
+    await removeLocks(targetDir);
+    return {
+        source: sourceDir,
+        profileName,
+        method: result.method,
+        status: result.copied ? 'copied' : 'skipped',
+    };
+}
+async function copyWithRsync(sourceDir, targetDir, logger) {
+    const rsyncArgs = [
+        '-a',
+        '--delete',
+        ...DIR_EXCLUDES.flatMap((entry) => ['--exclude', entry]),
+        ...FILE_EXCLUDES.flatMap((entry) => ['--exclude', entry]),
+        `${sourceDir}/`,
+        `${targetDir}/`,
+    ];
+    const attempt = spawnSync('rsync', rsyncArgs, { stdio: 'pipe' });
+    if (!attempt.error && (attempt.status ?? 0) === 0) {
+        return { copied: true, method: 'rsync' };
+    }
+    logger?.('rsync unavailable or failed; falling back to Node copy');
+    await copyDirWithFilter(sourceDir, targetDir);
+    return copyWithNodeFs();
+}
+async function copyWithRobocopy(sourceDir, targetDir, logger) {
+    const args = [sourceDir, targetDir, '/MIR', '/NFL', '/NDL', '/NJH', '/NJS', '/NP', '/Z'];
+    if (DIR_EXCLUDES.length) {
+        args.push('/XD', ...DIR_EXCLUDES);
+    }
+    if (FILE_EXCLUDES.length) {
+        args.push('/XF', ...FILE_EXCLUDES);
+    }
+    const attempt = spawnSync('robocopy', args, { stdio: 'pipe' });
+    const exitCode = attempt.status ?? 0;
+    // Robocopy treats 0-7 as success/partial success; >=8 is failure.
+    if (!attempt.error && exitCode < 8) {
+        return { copied: true, method: 'robocopy' };
+    }
+    logger?.('robocopy failed; falling back to Node copy');
+    await copyDirWithFilter(sourceDir, targetDir);
+    return copyWithNodeFs();
+}
+function copyWithNodeFs() {
+    return { copied: true, method: 'node' };
+}
+function shouldExclude(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    return DIR_EXCLUDES.some((entry) => normalized === entry || normalized.startsWith(`${entry}/`)) ||
+        FILE_EXCLUDES.some((entry) => {
+            if (entry.endsWith('*')) {
+                return normalized.startsWith(entry.slice(0, -1));
+            }
+            if (entry.includes('*')) {
+                // simple glob support for BrowserMetrics*
+                const prefix = entry.replace('*', '');
+                return normalized.startsWith(prefix);
+            }
+            return path.basename(normalized) === entry || normalized.endsWith(`/${entry}`);
+        });
+}
+async function removeLocks(targetDir) {
+    const lockNames = ['SingletonLock', 'SingletonSocket', 'SingletonCookie', 'DevToolsActivePort'];
+    for (const lock of lockNames) {
+        await rm(path.join(targetDir, lock), { force: true }).catch(() => undefined);
+        await rm(path.join(targetDir, 'Default', lock), { force: true }).catch(() => undefined);
+    }
+}
+async function resolveProfileSource(profile, explicitPath) {
+    const profileName = profile?.trim() ? profile.trim() : 'Default';
+    if (explicitPath?.trim()) {
+        const resolved = expandPath(explicitPath.trim());
+        if (resolved.toLowerCase().endsWith('cookies')) {
+            return { sourceDir: path.dirname(resolved), profileName };
+        }
+        return { sourceDir: resolved, profileName };
+    }
+    if (looksLikePath(profileName)) {
+        return { sourceDir: expandPath(profileName), profileName };
+    }
+    const baseRoot = await defaultProfileRoot();
+    return { sourceDir: path.join(baseRoot, profileName), profileName };
+}
+async function copyDirWithFilter(sourceDir, targetDir) {
+    await copyDir(sourceDir, targetDir, {
+        recursive: true,
+        filter: async (source) => {
+            const rel = path.relative(sourceDir, source);
+            if (!rel)
+                return true;
+            return !shouldExclude(rel);
+        },
+    });
+}

package/dist/src/browser/prompt.js

@@ -2,6 +2,7 @@ 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';
 export async function assembleBrowserPrompt(runOptions, deps = {}) {
@@ -48,7 +49,8 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         });
     }
     const inlineFileCount = attachmentPlan.inlineFileCount;
-    const tokenizer = MODEL_CONFIGS[runOptions.model].tokenizer;
+    const modelConfig = isKnownModel(runOptions.model) ? MODEL_CONFIGS[runOptions.model] : MODEL_CONFIGS['gpt-5.1'];
+    const tokenizer = modelConfig.tokenizer;
     const tokenizerUserContent = inlineFileCount > 0 && attachmentPlan.inlineBlock
         ? [userPrompt, attachmentPlan.inlineBlock].filter((value) => Boolean(value?.trim())).join('\n\n').trim()
         : userPrompt;

package/dist/src/browser/reattach.js

@@ -0,0 +1,59 @@
+import CDP from 'chrome-remote-interface';
+import { waitForAssistantResponse, captureAssistantMarkdown } from './pageActions.js';
+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 async function resumeBrowserSession(runtime, config, logger, deps = {}) {
+    if (!runtime.chromePort) {
+        throw new Error('Missing chromePort; cannot reattach.');
+    }
+    const host = runtime.chromeHost ?? '127.0.0.1';
+    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 waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
+    const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
+    const timeoutMs = config?.timeoutMs ?? 120_000;
+    const answer = await waitForResponse(Runtime, timeoutMs, logger);
+    const markdown = (await captureMarkdown(Runtime, answer.meta, logger)) ?? answer.text;
+    if (client && typeof client.close === 'function') {
+        try {
+            await client.close();
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { answerText: answer.text, answerMarkdown: markdown };
+}

package/dist/src/browser/sessionRunner.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { formatElapsed } from '../oracle.js';
+import { formatTokenCount } from '../oracle/runUtils.js';
 import { runBrowserMode } from '../browserMode.js';
 import { assembleBrowserPrompt } from './prompt.js';
 import { BrowserAutomationError } from '../oracle/errors.js';
@@ -46,6 +47,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     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({
@@ -55,6 +57,9 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             log: automationLogger,
             heartbeatIntervalMs: runOptions.heartbeatIntervalMs,
             verbose: runOptions.verbose,
+            runtimeHintCb: async (runtime) => {
+                await persistRuntimeHint({ ...runtime, controllerPid: runtime.controllerPid ?? process.pid });
+            },
         });
     }
     catch (error) {
@@ -76,7 +81,14 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         reasoningTokens: 0,
         totalTokens: promptArtifacts.estimatedInputTokens + browserResult.answerTokens,
     };
-    const tokensDisplay = `${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens}`;
+    const tokensDisplay = [
+        usage.inputTokens,
+        usage.outputTokens,
+        usage.reasoningTokens,
+        usage.totalTokens,
+    ]
+        .map((value) => formatTokenCount(value))
+        .join('/');
     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) {
@@ -89,7 +101,9 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         runtime: {
             chromePid: browserResult.chromePid,
             chromePort: browserResult.chromePort,
+            chromeHost: browserResult.chromeHost,
             userDataDir: browserResult.userDataDir,
+            controllerPid: browserResult.controllerPid ?? process.pid,
         },
         answerText,
     };

package/dist/src/browser/windowsCookies.js

@@ -65,7 +65,8 @@ export async function loadWindowsCookies(dbPath, filterNames) {
 }
 function decryptCookie(value, aesKey) {
     const prefix = value.slice(0, 3).toString();
-    if (prefix === 'v10' || prefix === 'v11') {
+    // Chrome prefixes AES-GCM encrypted cookies with version markers like v10/v11/v20; treat all v** the same.
+    if (/^v\d{2}$/u.test(prefix)) {
         const iv = value.slice(3, 15);
         const tag = value.slice(value.length - 16);
         const data = value.slice(15, value.length - 16);

package/dist/src/cli/browserConfig.js

@@ -35,6 +35,7 @@ export async function buildBrowserConfig(options) {
         chromePath: options.browserChromePath ?? null,
         chromeCookiePath: options.browserCookiePath ?? null,
         url,
+        debugPort: selectBrowserPort(options),
         timeoutMs: options.browserTimeout ? parseDuration(options.browserTimeout, DEFAULT_BROWSER_TIMEOUT_MS) : undefined,
         inputTimeoutMs: options.browserInputTimeout
             ? parseDuration(options.browserInputTimeout, DEFAULT_BROWSER_INPUT_TIMEOUT_MS)
@@ -45,6 +46,7 @@ export async function buildBrowserConfig(options) {
         inlineCookiesSource: inline?.source ?? null,
         headless: undefined, // disable headless; Cloudflare blocks it
         keepBrowser: options.browserKeepBrowser ? true : undefined,
+        manualLogin: options.browserManualLogin ? true : undefined,
         hideWindow: options.browserHideWindow ? true : undefined,
         desiredModel: shouldUseOverride ? desiredModelOverride : mapModelToBrowserLabel(options.model),
         debug: options.verbose ? true : undefined,
@@ -53,6 +55,15 @@ export async function buildBrowserConfig(options) {
         remoteChrome,
     };
 }
+function selectBrowserPort(options) {
+    const candidate = options.browserPort ?? options.browserDebugPort;
+    if (candidate === undefined || candidate === null)
+        return null;
+    if (!Number.isFinite(candidate) || candidate <= 0 || candidate > 65_535) {
+        throw new Error(`Invalid browser port: ${candidate}. Expected a number between 1 and 65535.`);
+    }
+    return candidate;
+}
 export function mapModelToBrowserLabel(model) {
     return BROWSER_MODEL_LABELS[model] ?? DEFAULT_MODEL_TARGET;
 }

package/dist/src/cli/browserDefaults.js

@@ -0,0 +1,41 @@
+import { normalizeChatgptUrl, CHATGPT_URL } from '../browserMode.js';
+export function applyBrowserDefaultsFromConfig(options, config, getSource) {
+    const browser = config.browser;
+    if (!browser)
+        return;
+    const configuredChatgptUrl = browser.chatgptUrl ?? browser.url;
+    const cliChatgptSet = options.chatgptUrl !== undefined || options.browserUrl !== undefined;
+    if ((getSource('chatgptUrl') === 'default' || getSource('chatgptUrl') === undefined) && !cliChatgptSet && configuredChatgptUrl !== undefined) {
+        options.chatgptUrl = normalizeChatgptUrl(configuredChatgptUrl ?? '', CHATGPT_URL);
+    }
+    if (getSource('browserChromeProfile') === 'default' && browser.chromeProfile !== undefined) {
+        options.browserChromeProfile = browser.chromeProfile ?? undefined;
+    }
+    if (getSource('browserChromePath') === 'default' && browser.chromePath !== undefined) {
+        options.browserChromePath = browser.chromePath ?? undefined;
+    }
+    if (getSource('browserCookiePath') === 'default' && browser.chromeCookiePath !== undefined) {
+        options.browserCookiePath = browser.chromeCookiePath ?? undefined;
+    }
+    if ((getSource('browserUrl') === 'default' || getSource('browserUrl') === undefined) && options.browserUrl === undefined && browser.url !== undefined) {
+        options.browserUrl = browser.url;
+    }
+    if (getSource('browserTimeout') === 'default' && typeof browser.timeoutMs === 'number') {
+        options.browserTimeout = String(browser.timeoutMs);
+    }
+    if (getSource('browserPort') === 'default' && typeof browser.debugPort === 'number') {
+        options.browserPort = browser.debugPort;
+    }
+    if (getSource('browserInputTimeout') === 'default' && typeof browser.inputTimeoutMs === 'number') {
+        options.browserInputTimeout = String(browser.inputTimeoutMs);
+    }
+    if (getSource('browserHeadless') === 'default' && browser.headless !== undefined) {
+        options.browserHeadless = browser.headless;
+    }
+    if (getSource('browserHideWindow') === 'default' && browser.hideWindow !== undefined) {
+        options.browserHideWindow = browser.hideWindow;
+    }
+    if (getSource('browserKeepBrowser') === 'default' && browser.keepBrowser !== undefined) {
+        options.browserKeepBrowser = browser.keepBrowser;
+    }
+}

package/dist/src/cli/detach.js

@@ -1,11 +1,11 @@
-import { PRO_MODELS } from '../oracle.js';
+import { isProModel } from '../oracle/modelResolver.js';
 export function shouldDetachSession({ 
 // Params kept for future policy tweaks; currently only model/disableDetachEnv matter.
 engine, model, waitPreference: _waitPreference, disableDetachEnv, }) {
     if (disableDetachEnv)
         return false;
     // Only Pro-tier API runs should start detached by default; browser runs stay inline so failures surface.
-    if (PRO_MODELS.has(model) && engine === 'api')
+    if (isProModel(model) && engine === 'api')
         return true;
     return false;
 }

package/dist/src/cli/dryRun.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { MODEL_CONFIGS, TOKENIZER_OPTIONS, DEFAULT_SYSTEM_PROMPT, buildPrompt, readFiles, getFileTokenStats, printFileTokenStats, } from '../oracle.js';
+import { isKnownModel } from '../oracle/modelResolver.js';
 import { assembleBrowserPrompt } from '../browser/prompt.js';
 import { buildTokenEstimateSuffix, formatAttachmentLabel } from '../browser/promptSummary.js';
 import { buildCookiePlan } from '../browser/policies.js';
@@ -15,7 +16,8 @@ async function runApiDryRun({ runOptions, cwd, version, log, }, deps) {
     const files = await readFilesImpl(runOptions.file ?? [], { cwd });
     const systemPrompt = runOptions.system?.trim() || DEFAULT_SYSTEM_PROMPT;
     const combinedPrompt = buildPrompt(runOptions.prompt ?? '', files, cwd);
-    const tokenizer = MODEL_CONFIGS[runOptions.model].tokenizer;
+    const modelConfig = isKnownModel(runOptions.model) ? MODEL_CONFIGS[runOptions.model] : MODEL_CONFIGS['gpt-5.1'];
+    const tokenizer = modelConfig.tokenizer;
     const estimatedInputTokens = tokenizer([
         { role: 'system', content: systemPrompt },
         { role: 'user', content: combinedPrompt },
@@ -26,7 +28,7 @@ async function runApiDryRun({ runOptions, cwd, version, log, }, deps) {
         log(chalk.dim('[dry-run] No files matched the provided --file patterns.'));
         return;
     }
-    const inputBudget = runOptions.maxInput ?? MODEL_CONFIGS[runOptions.model].inputLimit;
+    const inputBudget = runOptions.maxInput ?? modelConfig.inputLimit;
     const stats = getFileTokenStats(files, {
         cwd,
         tokenizer,

package/dist/src/cli/engine.js

@@ -1,7 +1,7 @@
-import { PRO_MODELS } from '../oracle.js';
+import { isProModel } from '../oracle/modelResolver.js';
 export function defaultWaitPreference(model, engine) {
     // Pro-class API runs can take a long time; prefer non-blocking unless explicitly overridden.
-    if (engine === 'api' && PRO_MODELS.has(model)) {
+    if (engine === 'api' && isProModel(model)) {
         return false;
     }
     return true; // browser or non-pro models are fast enough to block by default

package/dist/src/cli/help.js

@@ -38,12 +38,12 @@ export function applyHelpStyling(program, version, isTty) {
     program.addHelpText('after', () => renderHelpFooter(program, colors));
 }
 function renderHelpBanner(version, colors) {
-    const subtitle = 'GPT-5.1 Pro/GPT-5.1 for tough questions with code/file context.';
+    const subtitle = 'Prompt + files required — GPT-5.1 Pro/GPT-5.1 for tough questions with code/file context.';
     return `${colors.banner(`Oracle CLI v${version}`)} ${colors.subtitle(`— ${subtitle}`)}\n`;
 }
 function renderHelpFooter(program, colors) {
     const tips = [
-        `${colors.bullet('•')} Oracle cannot see your project unless you pass ${colors.accent('--file …')} — attach the files/dirs you want it to read.`,
+        `${colors.bullet('•')} Required: always pass a prompt AND ${colors.accent('--file …')} (directories/globs are fine); Oracle cannot see your project otherwise.`,
         `${colors.bullet('•')} Attach lots of source (whole directories beat single files) and keep total input under ~196k tokens.`,
         `${colors.bullet('•')} Oracle starts empty—open with a short project briefing (stack, services, build steps), spell out the question and prior attempts, and why it matters; the more explanation and context you provide, the better the response will be.`,
         `${colors.bullet('•')} Spell out the project + platform + version requirements (repo name, target OS/toolchain versions, API dependencies) so Oracle doesn’t guess defaults.`,

package/dist/src/cli/options.js

@@ -149,7 +149,8 @@ export function resolveApiModel(modelValue) {
     if (normalized.includes('gemini')) {
         return 'gemini-3-pro';
     }
-    throw new InvalidArgumentError(`Unsupported model "${modelValue}". Choose one of: ${Object.keys(MODEL_CONFIGS).join(', ')}`);
+    // Passthrough for custom/OpenRouter model IDs.
+    return normalized;
 }
 export function inferModelFromLabel(modelValue) {
     const normalized = normalizeModelOption(modelValue).toLowerCase();

package/dist/src/cli/runOptions.js

@@ -64,7 +64,7 @@ function resolveEngineWithConfig({ engine, configEngine, env, }) {
     return resolveEngine({ engine: undefined, env });
 }
 function resolveEffectiveModelId(model) {
-    if (model.startsWith('gemini')) {
+    if (typeof model === 'string' && model.startsWith('gemini')) {
         return resolveGeminiModelId(model);
     }
     const config = MODEL_CONFIGS[model];