@steipete/oracle 0.12.0 → 0.13.0

package/dist/src/cli/runOptions.js

@@ -7,14 +7,17 @@ import { normalizeChatGptModelForBrowser } from "./browserConfig.js";
 import { resolveConfiguredMaxFileSizeBytes } from "./fileSize.js";
 import { isAzureOpenAICandidateModel } from "../oracle/providerRouting.js";
 export function resolveRunOptionsFromConfig({ prompt, files = [], model, models, engine, userConfig, env = process.env, }) {
-    const resolvedEngine = resolveEngineWithConfig({
+    const resolvedEngine = resolveEngine({
         engine,
         configEngine: userConfig?.engine,
         env,
     });
+    const envEnginePreference = (env.ORACLE_ENGINE ?? "").trim().toLowerCase();
     const browserRequested = engine === "browser";
-    const browserConfigured = userConfig?.engine === "browser";
-    const envBrowserConfigured = (env.ORACLE_ENGINE ?? "").trim().toLowerCase() === "browser";
+    const explicitApiEngineRequested = engine === "api" || (!engine && envEnginePreference === "api");
+    const browserConfigured = userConfig?.engine === "browser" && !explicitApiEngineRequested;
+    const envBrowserConfigured = !engine && envEnginePreference === "browser";
+    const browserEngineRequested = browserRequested || browserConfigured || envBrowserConfigured;
     const requestedModelList = Array.isArray(models) ? models : [];
     const normalizedRequestedModels = requestedModelList
         .map((entry) => normalizeModelOption(entry))
@@ -32,20 +35,17 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
         : [apiModel];
     const browserCompatibilityModels = normalizedRequestedModels.length > 0 ? allModels : [browserModel];
     const includesGeminiApiOnly = allModels.some((m) => m === "gemini-3.1-pro");
-    if ((browserRequested || browserConfigured) && includesGeminiApiOnly) {
+    if (browserEngineRequested && includesGeminiApiOnly) {
         throw new PromptValidationError("gemini-3.1-pro is API-only today. Use --engine api or switch to gemini-3-pro for Gemini web.", { engine: "browser", models: allModels });
     }
     const isBrowserCompatible = (m) => m.startsWith("gpt-") || m.startsWith("gemini");
-    const hasNonBrowserCompatibleTarget = (browserRequested || browserConfigured) &&
-        browserCompatibilityModels.some((m) => !isBrowserCompatible(m));
+    const hasNonBrowserCompatibleTarget = browserEngineRequested && browserCompatibilityModels.some((m) => !isBrowserCompatible(m));
     if (hasNonBrowserCompatibleTarget) {
         throw new PromptValidationError("Browser engine only supports GPT and Gemini models. Re-run with --engine api for Grok, Claude, or other models.", { engine: "browser", models: allModels });
     }
     const azure = resolveAzureOptions(userConfig, env);
     const azureAutoApi = Boolean(azure?.endpoint) &&
-        !browserRequested &&
-        !browserConfigured &&
-        !envBrowserConfigured &&
+        !browserEngineRequested &&
         allModels.some(isAzureOpenAICandidateModel);
     const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok || isGeminiApiOnly || azureAutoApi);
     const fixedEngine = isCodex ||
@@ -89,17 +89,6 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     };
     return { runOptions, resolvedEngine: fixedEngine, engineCoercedToApi };
 }
-function resolveEngineWithConfig({ engine, configEngine, apiProviderRequested, env, }) {
-    if (engine)
-        return engine;
-    const envOverride = (env.ORACLE_ENGINE ?? "").trim().toLowerCase();
-    if (envOverride === "api" || envOverride === "browser") {
-        return envOverride;
-    }
-    if (configEngine)
-        return configEngine;
-    return resolveEngine({ engine: undefined, apiProviderRequested, env });
-}
 function resolveAzureOptions(userConfig, env) {
     const endpoint = env.AZURE_OPENAI_ENDPOINT ?? userConfig?.azure?.endpoint;
     if (!endpoint?.trim()) {

package/dist/src/cli/sessionDisplay.js

@@ -6,6 +6,7 @@ import { formatFinishLine } from "../oracle/finishLine.js";
 import { sessionStore, wait } from "../sessionStore.js";
 import { formatTokenCount, formatTokenValue } from "../oracle/runUtils.js";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "../browser/artifacts.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatSessionTableHeader, formatSessionTableRow, resolveSessionCost, } from "./sessionTable.js";
@@ -174,9 +175,16 @@ export async function attachSession(sessionId, options) {
         hasFallbackSessionInfo &&
         isDeepResearchPlaceholderCapture(metadata, await sessionStore.readLog(sessionId).catch(() => ""));
     const completedDeepResearchPlaceholder = metadata.status === "completed" && deepResearchPlaceholderCapture;
+    const hasRecoverableConversation = hasRecoverableChatGptConversation(runtime);
+    const hasLiveChromeFallback = Boolean((metadata.status === "running" || hasIncompleteCapture || completedDeepResearchPlaceholder) &&
+        (runtime?.chromePort || runtime?.chromeBrowserWSEndpoint || runtime?.chromeProfileRoot));
     const canReattach = (statusAllowsReattach || completedDeepResearchPlaceholder) &&
         metadata.mode === "browser" &&
         hasFallbackSessionInfo &&
+        (hasRecoverableConversation ||
+            runtime?.promptSubmitted ||
+            hasLiveChromeFallback ||
+            completedDeepResearchPlaceholder) &&
         (hasChromeDisconnect ||
             hasIncompleteCapture ||
             completedDeepResearchPlaceholder ||

package/dist/src/cli/sessionRunner.js

@@ -21,6 +21,7 @@ import { sanitizeOscProgress } from "./oscUtils.js";
 import { readFiles } from "../oracle/files.js";
 import { cwd as getCwd } from "node:process";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatElapsed } from "../oracle/format.js";
 const isTty = process.stdout.isTTY;
@@ -390,6 +391,40 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         if (connectionLost && mode === "browser") {
             const runtime = userError.details
                 ?.runtime;
+            const recoverableRuntime = runtime ?? sessionMeta.browser?.runtime;
+            if (!hasRecoverableChatGptConversation(recoverableRuntime) &&
+                recoverableRuntime?.promptSubmitted !== true) {
+                log(dim("Chrome disconnected before a ChatGPT conversation was created; marking session error."));
+                if (modelForStatus) {
+                    await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                        status: "error",
+                        completedAt: new Date().toISOString(),
+                        response: { status: "error", incompleteReason: "chrome-disconnected" },
+                        error: {
+                            category: userError.category,
+                            message: userError.message,
+                            details: userError.details,
+                        },
+                    });
+                }
+                await sessionStore.updateSession(sessionMeta.id, {
+                    status: "error",
+                    completedAt: new Date().toISOString(),
+                    errorMessage: message,
+                    mode,
+                    browser: {
+                        config: browserConfig,
+                        runtime: recoverableRuntime,
+                    },
+                    response: { status: "error", incompleteReason: "chrome-disconnected" },
+                    error: {
+                        category: userError.category,
+                        message: userError.message,
+                        details: userError.details,
+                    },
+                });
+                throw error;
+            }
             log(dim("Chrome disconnected before completion; keeping session running for reattach."));
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
@@ -576,13 +611,22 @@ function sanitizeMultiModelFailureForThrow(error, context) {
     if (!(error instanceof Error)) {
         return new Error(message);
     }
-    error.message = message;
+    let sanitized;
+    if (error instanceof OracleTransportError) {
+        sanitized = new OracleTransportError(error.reason, message);
+    }
+    else if (error instanceof OracleResponseError) {
+        sanitized = new OracleResponseError(message, error.response);
+    }
+    else {
+        sanitized = new Error(message);
+        sanitized.name = error.name;
+    }
     if (error.stack) {
-        const [firstLine, ...rest] = error.stack.split("\n");
-        const prefix = firstLine.includes(":") ? firstLine.split(":", 1)[0] : error.name;
-        error.stack = [prefix ? `${prefix}: ${message}` : message, ...rest].join("\n");
+        const [, ...rest] = error.stack.split("\n");
+        sanitized.stack = [sanitized.name ? `${sanitized.name}: ${message}` : message, ...rest].join("\n");
     }
-    return error;
+    return sanitized;
 }
 export function deriveOutputManifestPath(basePath) {
     const ext = path.extname(basePath);

package/dist/src/config.js

@@ -1,26 +1,181 @@
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import JSON5 from "json5";
 import { getOracleHomeDir } from "./oracleHome.js";
-function resolveConfigPath() {
+export const PROJECT_CONFIG_RELATIVE_PATH = path.join(".oracle", "config.json");
+function resolveUserConfigPath() {
     return path.join(getOracleHomeDir(), "config.json");
 }
-export async function loadUserConfig() {
-    const CONFIG_PATH = resolveConfigPath();
+export async function loadUserConfig(options = {}) {
+    const userConfigPath = resolveUserConfigPath();
+    const userConfig = await readConfigFile(userConfigPath);
+    const projectConfigPaths = options.includeProject === false
+        ? []
+        : await discoverProjectConfigPaths({
+            cwd: options.cwd ?? process.cwd(),
+            userConfigPath,
+        });
+    const loadedConfigs = [];
+    if (userConfig.loaded) {
+        loadedConfigs.push(userConfig);
+    }
+    let merged = userConfig.loaded ? userConfig.config : {};
+    for (const projectConfigPath of projectConfigPaths) {
+        const projectConfig = await readConfigFile(projectConfigPath);
+        if (!projectConfig.loaded)
+            continue;
+        loadedConfigs.push(projectConfig);
+        merged = mergeUserConfig(merged, sanitizeProjectConfig(projectConfig.config));
+    }
+    const loadedPaths = loadedConfigs.map((entry) => entry.path);
+    return {
+        config: merged,
+        path: userConfigPath,
+        paths: loadedPaths,
+        loaded: userConfig.loaded,
+    };
+}
+async function readConfigFile(configPath) {
     try {
-        const raw = await fs.readFile(CONFIG_PATH, "utf8");
+        const raw = await fs.readFile(configPath, "utf8");
         const parsed = JSON5.parse(raw);
-        return { config: parsed ?? {}, path: CONFIG_PATH, loaded: true };
+        return { config: parsed ?? {}, path: configPath, loaded: true };
     }
     catch (error) {
         const code = error.code;
         if (code === "ENOENT") {
-            return { config: {}, path: CONFIG_PATH, loaded: false };
+            return { config: {}, path: configPath, loaded: false };
         }
-        console.warn(`Failed to read ${CONFIG_PATH}: ${error instanceof Error ? error.message : String(error)}`);
-        return { config: {}, path: CONFIG_PATH, loaded: false };
+        console.warn(`Failed to read ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+        return { config: {}, path: configPath, loaded: false };
     }
 }
 export function configPath() {
-    return resolveConfigPath();
+    return resolveUserConfigPath();
+}
+async function discoverProjectConfigPaths({ cwd, userConfigPath, }) {
+    const start = path.resolve(cwd);
+    const home = os.homedir();
+    const candidates = [];
+    const seen = new Set([path.resolve(userConfigPath)]);
+    let current = start;
+    while (true) {
+        if (current === home) {
+            break;
+        }
+        const candidate = path.join(current, PROJECT_CONFIG_RELATIVE_PATH);
+        const resolved = path.resolve(candidate);
+        if (!seen.has(resolved)) {
+            try {
+                const stat = await fs.stat(resolved);
+                if (stat.isFile()) {
+                    candidates.unshift(resolved);
+                    seen.add(resolved);
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    console.warn(`Failed to inspect ${resolved}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return candidates;
+}
+function mergeUserConfig(base, override) {
+    return deepMerge(base, override);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, override) {
+    if (!isRecord(base) || !isRecord(override)) {
+        return override;
+    }
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        const existing = result[key];
+        result[key] = isRecord(existing) && isRecord(value) ? deepMerge(existing, value) : value;
+    }
+    return result;
+}
+function sanitizeProjectConfig(config) {
+    const sanitized = {};
+    if (config.engine !== undefined)
+        sanitized.engine = config.engine;
+    if (config.model !== undefined)
+        sanitized.model = config.model;
+    if (config.search !== undefined)
+        sanitized.search = config.search;
+    if (config.maxFileSizeBytes !== undefined)
+        sanitized.maxFileSizeBytes = config.maxFileSizeBytes;
+    if (config.notify !== undefined)
+        sanitized.notify = config.notify;
+    if (config.heartbeatSeconds !== undefined)
+        sanitized.heartbeatSeconds = config.heartbeatSeconds;
+    if (config.filesReport !== undefined)
+        sanitized.filesReport = config.filesReport;
+    if (config.background !== undefined)
+        sanitized.background = config.background;
+    if (config.promptSuffix !== undefined)
+        sanitized.promptSuffix = config.promptSuffix;
+    if (config.browser) {
+        sanitized.browser = {};
+        const browser = config.browser;
+        const allowedBrowserKeys = [
+            "attachRunning",
+            "timeoutMs",
+            "inputTimeoutMs",
+            "attachmentTimeoutMs",
+            "assistantRecheckDelayMs",
+            "assistantRecheckTimeoutMs",
+            "reuseChromeWaitMs",
+            "profileLockTimeoutMs",
+            "maxConcurrentTabs",
+            "autoReattachDelayMs",
+            "autoReattachIntervalMs",
+            "autoReattachTimeoutMs",
+            "cookieSyncWaitMs",
+            "hideWindow",
+            "keepBrowser",
+            "modelStrategy",
+            "thinkingTime",
+            "researchMode",
+            "archiveConversations",
+            "manualLogin",
+        ];
+        for (const key of allowedBrowserKeys) {
+            if (browser[key] !== undefined) {
+                sanitized.browser[key] = browser[key];
+            }
+        }
+        const chatgptUrl = browser.chatgptUrl ?? browser.url;
+        if (chatgptUrl === null ||
+            (chatgptUrl !== undefined && isTrustedProjectChatgptUrl(chatgptUrl))) {
+            sanitized.browser.chatgptUrl = chatgptUrl;
+            sanitized.browser.url = chatgptUrl;
+        }
+    }
+    return sanitized;
+}
+function isTrustedProjectChatgptUrl(rawUrl) {
+    if (!rawUrl) {
+        return false;
+    }
+    try {
+        const parsed = new URL(rawUrl);
+        if (parsed.protocol !== "https:") {
+            return false;
+        }
+        return parsed.hostname === "chatgpt.com" || parsed.hostname === "chat.openai.com";
+    }
+    catch {
+        return false;
+    }
 }

package/dist/src/oracle/providerRoutePlan.js

@@ -8,7 +8,14 @@ const DEFAULT_PROVIDER_HOSTS = {
     openai: "api.openai.com",
     xai: "api.x.ai",
 };
+export function resolveProviderRoute(input) {
+    return buildResolvedProviderRoute(input);
+}
 export function buildProviderRoutePlan(input) {
+    const { apiKey: _apiKey, baseUrl: _baseUrl, nativeProvider: _nativeProvider, openRouterFallback: _openRouterFallback, azureEndpoint: _azureEndpoint, ...plan } = buildResolvedProviderRoute(input);
+    return plan;
+}
+function buildResolvedProviderRoute(input) {
     const env = input.env ?? process.env;
     const providerMode = input.providerMode ?? "auto";
     const azureConfigured = Boolean(input.azure?.endpoint?.trim());
@@ -49,7 +56,12 @@ export function buildProviderRoutePlan(input) {
             keySource: key.source,
             keyPreview: key.preview,
             keyPresent: key.present,
+            apiKey: key.value,
+            nativeProvider: provider,
+            baseUrl: input.baseUrl,
+            openRouterFallback: false,
             isAzureOpenAI,
+            azureEndpoint: state?.azureEndpoint ?? input.azure?.endpoint,
             azureConfigured,
             azureDeploymentName: state?.azureDeploymentName,
             azureNote: azureNote(providerMode, azureConfigured, isAzureOpenAI),
@@ -145,7 +157,12 @@ export function buildProviderRoutePlan(input) {
         keySource: key.source,
         keyPreview: key.preview,
         keyPresent: key.present,
+        apiKey: key.value,
+        nativeProvider: provider,
+        baseUrl,
+        openRouterFallback,
         isAzureOpenAI,
+        azureEndpoint: state.azureEndpoint,
         azureConfigured,
         azureDeploymentName: state.azureDeploymentName,
         azureNote: azureNote(providerMode, azureConfigured, isAzureOpenAI),
@@ -166,7 +183,12 @@ function getNativeKey({ model, provider, providerMode, isAzureOpenAI, apiKey, en
 }
 function getKeyForRoute({ model, provider, providerMode, isAzureOpenAI, baseUrl, openRouterFallback, apiKey, env, }) {
     if (apiKey) {
-        return { source: "apiKey option", preview: maskApiKey(apiKey) ?? "set", present: true };
+        return {
+            source: "apiKey option",
+            preview: maskApiKey(apiKey) ?? "set",
+            present: true,
+            value: apiKey,
+        };
     }
     if (isAzureOpenAI) {
         return readKey(["AZURE_OPENAI_API_KEY", "OPENAI_API_KEY"], env);
@@ -201,7 +223,12 @@ function readKey(names, env) {
     for (const name of names) {
         const value = env[name]?.trim();
         if (value) {
-            return { source: name, preview: `${name}=${maskApiKey(value) ?? "set"}`, present: true };
+            return {
+                source: name,
+                preview: `${name}=${maskApiKey(value) ?? "set"}`,
+                present: true,
+                value,
+            };
         }
     }
     return { source: names.join("|"), preview: "missing", present: false };