@steipete/oracle 0.12.1 → 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/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/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.5 Pro, GPT-5.5, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
-  "homepage": "https://github.com/steipete/oracle#readme",
+  "homepage": "https://askoracle.sh",
   "bugs": {
     "url": "https://github.com/steipete/oracle/issues"
   },