@steipete/oracle 1.1.0 → 1.3.0

package/dist/src/config.js

@@ -0,0 +1,27 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import JSON5 from 'json5';
+function resolveConfigPath() {
+    const oracleHome = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
+    return path.join(oracleHome, 'config.json');
+}
+export async function loadUserConfig() {
+    const CONFIG_PATH = resolveConfigPath();
+    try {
+        const raw = await fs.readFile(CONFIG_PATH, 'utf8');
+        const parsed = JSON5.parse(raw);
+        return { config: parsed ?? {}, path: CONFIG_PATH, loaded: true };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT') {
+            return { config: {}, path: CONFIG_PATH, loaded: false };
+        }
+        console.warn(`Failed to read ${CONFIG_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+        return { config: {}, path: CONFIG_PATH, loaded: false };
+    }
+}
+export function configPath() {
+    return resolveConfigPath();
+}

package/dist/src/mcp/server.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import process from 'node:process';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { getCliVersion } from '../version.js';
+import { registerConsultTool } from './tools/consult.js';
+import { registerSessionsTool } from './tools/sessions.js';
+import { registerSessionResources } from './tools/sessionResources.js';
+export async function startMcpServer() {
+    const server = new McpServer({
+        name: 'oracle-mcp',
+        version: getCliVersion(),
+    }, {
+        capabilities: {
+            logging: {},
+        },
+    });
+    registerConsultTool(server);
+    registerSessionsTool(server);
+    registerSessionResources(server);
+    const transport = new StdioServerTransport();
+    transport.onerror = (error) => {
+        console.error('MCP transport error:', error);
+    };
+    transport.onclose = () => {
+        // Keep quiet on normal close; caller owns lifecycle.
+    };
+    await server.connect(transport);
+}
+if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith('oracle-mcp')) {
+    startMcpServer().catch((error) => {
+        console.error('Failed to start oracle-mcp:', error);
+        process.exitCode = 1;
+    });
+}

package/dist/src/mcp/tools/consult.js

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+import { getCliVersion } from '../../version.js';
+import { LoggingMessageNotificationParamsSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ensureBrowserAvailable, mapConsultToRunOptions } from '../utils.js';
+import { createSessionLogWriter, initializeSession, readSessionMetadata, readSessionLog, } from '../../sessionManager.js';
+async function readSessionLogTail(sessionId, maxBytes) {
+    try {
+        const log = await readSessionLog(sessionId);
+        if (log.length <= maxBytes) {
+            return log;
+        }
+        return log.slice(-maxBytes);
+    }
+    catch {
+        return null;
+    }
+}
+import { performSessionRun } from '../../cli/sessionRunner.js';
+import { CHATGPT_URL } from '../../browser/constants.js';
+import { consultInputSchema } from '../types.js';
+import { loadUserConfig } from '../../config.js';
+import { resolveNotificationSettings } from '../../cli/notifier.js';
+import { mapModelToBrowserLabel, resolveBrowserModelLabel } from '../../cli/browserConfig.js';
+// Use raw shapes so the MCP SDK (with its bundled Zod) wraps them and emits valid JSON Schema.
+const consultInputShape = {
+    prompt: z.string().min(1, 'Prompt is required.'),
+    files: z.array(z.string()).default([]),
+    model: z.string().optional(),
+    engine: z.enum(['api', 'browser']).optional(),
+    browserModelLabel: z.string().optional(),
+    search: z.boolean().optional(),
+    slug: z.string().optional(),
+};
+const consultOutputShape = {
+    sessionId: z.string(),
+    status: z.string(),
+    output: z.string(),
+};
+export function registerConsultTool(server) {
+    server.registerTool('consult', {
+        title: 'Run an oracle session',
+        description: 'Run a one-shot Oracle session (API or browser). Attach files/dirs for context, optional model/engine overrides, and an optional slug. Background handling follows the CLI defaults; browser runs only start when Chrome is available.',
+        // Cast to any to satisfy SDK typings across differing Zod versions.
+        inputSchema: consultInputShape,
+        outputSchema: consultOutputShape,
+    }, async (input) => {
+        const textContent = (text) => [{ type: 'text', text }];
+        const { prompt, files, model, engine, search, browserModelLabel, slug } = consultInputSchema.parse(input);
+        const { config: userConfig } = await loadUserConfig();
+        const { runOptions, resolvedEngine } = mapConsultToRunOptions({
+            prompt,
+            files: files ?? [],
+            model,
+            engine,
+            search,
+            userConfig,
+            env: process.env,
+        });
+        const cwd = process.cwd();
+        const browserGuard = ensureBrowserAvailable(resolvedEngine);
+        if (resolvedEngine === 'browser' &&
+            (browserGuard ||
+                (process.platform === 'linux' && !process.env.DISPLAY && !process.env.CHROME_PATH))) {
+            return {
+                isError: true,
+                content: textContent(browserGuard ?? 'Browser engine unavailable: set DISPLAY or CHROME_PATH.'),
+            };
+        }
+        let browserConfig;
+        if (resolvedEngine === 'browser') {
+            const preferredLabel = (browserModelLabel ?? model)?.trim();
+            const desiredModelLabel = resolveBrowserModelLabel(preferredLabel, runOptions.model);
+            // Keep the browser path minimal; only forward a desired model label for the ChatGPT picker.
+            browserConfig = {
+                url: CHATGPT_URL,
+                cookieSync: true,
+                headless: false,
+                hideWindow: false,
+                keepBrowser: false,
+                desiredModel: desiredModelLabel || mapModelToBrowserLabel(runOptions.model),
+            };
+        }
+        const notifications = resolveNotificationSettings({
+            cliNotify: undefined,
+            cliNotifySound: undefined,
+            env: process.env,
+            config: userConfig.notify,
+        });
+        const sessionMeta = await initializeSession({
+            ...runOptions,
+            mode: resolvedEngine,
+            slug,
+            browserConfig,
+        }, cwd, notifications);
+        const logWriter = createSessionLogWriter(sessionMeta.id);
+        // Best-effort: emit MCP logging notifications for live chunks but never block the run.
+        const sendLog = (text, level = 'info') => server.server
+            .sendLoggingMessage(LoggingMessageNotificationParamsSchema.parse({
+            level,
+            data: { text, bytes: Buffer.byteLength(text, 'utf8') },
+        }))
+            .catch(() => { });
+        // Stream logs to both the session log and MCP logging notifications, but avoid buffering in memory
+        const log = (line) => {
+            logWriter.logLine(line);
+            if (line !== undefined) {
+                sendLog(line);
+            }
+        };
+        const write = (chunk) => {
+            logWriter.writeChunk(chunk);
+            sendLog(chunk, 'debug');
+            return true;
+        };
+        try {
+            await performSessionRun({
+                sessionMeta,
+                runOptions,
+                mode: resolvedEngine,
+                browserConfig,
+                cwd,
+                log,
+                write,
+                version: getCliVersion(),
+                notifications,
+            });
+        }
+        catch (error) {
+            log(`Run failed: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                isError: true,
+                content: textContent(`Session ${sessionMeta.id} failed: ${error instanceof Error ? error.message : String(error)}`),
+            };
+        }
+        finally {
+            logWriter.stream.end();
+        }
+        try {
+            const finalMeta = (await readSessionMetadata(sessionMeta.id)) ?? sessionMeta;
+            const summary = `Session ${sessionMeta.id} (${finalMeta.status})`;
+            const logTail = await readSessionLogTail(sessionMeta.id, 4000);
+            return {
+                content: textContent([summary, logTail || '(log empty)'].join('\n').trim()),
+                structuredContent: {
+                    sessionId: sessionMeta.id,
+                    status: finalMeta.status,
+                    output: logTail ?? '',
+                },
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: textContent(`Session completed but metadata fetch failed: ${error instanceof Error ? error.message : String(error)}`),
+            };
+        }
+    });
+}

package/dist/src/mcp/tools/sessionResources.js

@@ -0,0 +1,64 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import fs from 'node:fs/promises';
+import { getSessionPaths, readSessionLog, readSessionMetadata } from '../../sessionManager.js';
+// URIs:
+// - oracle-session://<id>/metadata
+// - oracle-session://<id>/log
+// - oracle-session://<id>/request
+export function registerSessionResources(server) {
+    const template = new ResourceTemplate('oracle-session://{id}/{kind}', { list: undefined });
+    server.registerResource('oracle-session', template, {
+        title: 'oracle session resources',
+        description: 'Read stored session metadata, log, or request payload.',
+    }, async (uri, variables) => {
+        const idRaw = variables?.id;
+        const kindRaw = variables?.kind;
+        // uri-template variables arrive as string | string[]; collapse to first value.
+        const id = Array.isArray(idRaw) ? idRaw[0] : idRaw;
+        const kind = Array.isArray(kindRaw) ? kindRaw[0] : kindRaw;
+        if (!id || !kind) {
+            throw new Error('Missing id or kind');
+        }
+        const paths = await getSessionPaths(id);
+        switch (kind) {
+            case 'metadata': {
+                const metadata = await readSessionMetadata(id);
+                if (!metadata) {
+                    throw new Error(`Session "${id}" not found.`);
+                }
+                return {
+                    contents: [
+                        {
+                            uri: uri.href,
+                            text: JSON.stringify(metadata, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'log': {
+                const log = await readSessionLog(id);
+                return {
+                    contents: [
+                        {
+                            uri: uri.href,
+                            text: log,
+                        },
+                    ],
+                };
+            }
+            case 'request': {
+                const raw = await fs.readFile(paths.request, 'utf8');
+                return {
+                    contents: [
+                        {
+                            uri: uri.href,
+                            text: raw,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unsupported resource kind: ${kind}`);
+        }
+    });
+}

package/dist/src/mcp/tools/sessions.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs/promises';
+import { z } from 'zod';
+import { filterSessionsByRange, getSessionPaths, listSessionsMetadata, readSessionLog, readSessionMetadata, } from '../../sessionManager.js';
+import { sessionsInputSchema } from '../types.js';
+const sessionsInputShape = {
+    id: z.string().optional(),
+    hours: z.number().optional(),
+    limit: z.number().optional(),
+    includeAll: z.boolean().optional(),
+    detail: z.boolean().optional(),
+};
+const sessionsOutputShape = {
+    entries: z
+        .array(z.object({
+        id: z.string(),
+        createdAt: z.string(),
+        status: z.string(),
+        model: z.string().optional(),
+        mode: z.string().optional(),
+    }))
+        .optional(),
+    total: z.number().optional(),
+    truncated: z.boolean().optional(),
+    session: z
+        .object({
+        metadata: z.record(z.string(), z.any()),
+        log: z.string(),
+        request: z.record(z.string(), z.any()).optional(),
+    })
+        .optional(),
+};
+export function registerSessionsTool(server) {
+    server.registerTool('sessions', {
+        title: 'List or fetch oracle sessions',
+        description: 'List stored sessions (same defaults as `oracle status`) or, with id/slug, return a summary row. Pass detail:true to include metadata, log, and stored request for that session.',
+        inputSchema: sessionsInputShape,
+        outputSchema: sessionsOutputShape,
+    }, async (input) => {
+        const textContent = (text) => [{ type: 'text', text }];
+        const { id, hours = 24, limit = 100, includeAll = false, detail = false } = sessionsInputSchema.parse(input);
+        if (id) {
+            if (!detail) {
+                const metadata = await readSessionMetadata(id);
+                if (!metadata) {
+                    throw new Error(`Session "${id}" not found.`);
+                }
+                return {
+                    content: textContent(`${metadata.createdAt} | ${metadata.status} | ${metadata.model ?? 'n/a'} | ${metadata.id}`),
+                    structuredContent: {
+                        entries: [
+                            {
+                                id: metadata.id,
+                                createdAt: metadata.createdAt,
+                                status: metadata.status,
+                                model: metadata.model,
+                                mode: metadata.mode,
+                            },
+                        ],
+                        total: 1,
+                        truncated: false,
+                    },
+                };
+            }
+            const metadata = await readSessionMetadata(id);
+            if (!metadata) {
+                throw new Error(`Session "${id}" not found.`);
+            }
+            const log = await readSessionLog(id);
+            let request;
+            try {
+                const paths = await getSessionPaths(id);
+                const raw = await fs.readFile(paths.request, 'utf8');
+                // Old sessions may lack a request payload; treat it as best-effort metadata.
+                request = JSON.parse(raw);
+            }
+            catch {
+                request = undefined;
+            }
+            return {
+                content: textContent(log),
+                structuredContent: { session: { metadata, log, request } },
+            };
+        }
+        const metas = await listSessionsMetadata();
+        const { entries, truncated, total } = filterSessionsByRange(metas, { hours, includeAll, limit });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: entries.map((entry) => `${entry.createdAt} | ${entry.status} | ${entry.model ?? 'n/a'} | ${entry.id}`).join('\n'),
+                },
+            ],
+            structuredContent: {
+                entries: entries.map((entry) => ({
+                    id: entry.id,
+                    createdAt: entry.createdAt,
+                    status: entry.status,
+                    model: entry.model,
+                    mode: entry.mode,
+                })),
+                total,
+                truncated,
+            },
+        };
+    });
+}

package/dist/src/mcp/types.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export const consultInputSchema = z.object({
+    prompt: z.string().min(1, 'Prompt is required.'),
+    files: z.array(z.string()).default([]),
+    model: z.string().optional(),
+    engine: z.enum(['api', 'browser']).optional(),
+    browserModelLabel: z.string().optional(),
+    search: z.boolean().optional(),
+    slug: z.string().optional(),
+});
+export const sessionsInputSchema = z.object({
+    id: z.string().optional(),
+    hours: z.number().optional(),
+    limit: z.number().optional(),
+    includeAll: z.boolean().optional(),
+    detail: z.boolean().optional(),
+});

package/dist/src/mcp/utils.js

@@ -0,0 +1,24 @@
+import { resolveRunOptionsFromConfig } from '../cli/runOptions.js';
+import { Launcher } from 'chrome-launcher';
+export function mapConsultToRunOptions({ prompt, files, model, engine, search, userConfig, env = process.env, }) {
+    // Normalize CLI-style inputs through the shared resolver so config/env defaults apply,
+    // then overlay MCP-only overrides such as explicit search toggles.
+    const result = resolveRunOptionsFromConfig({ prompt, files, model, engine, userConfig, env });
+    if (typeof search === 'boolean') {
+        result.runOptions.search = search;
+    }
+    return result;
+}
+export function ensureBrowserAvailable(engine) {
+    if (engine !== 'browser') {
+        return null;
+    }
+    if (process.env.CHROME_PATH) {
+        return null;
+    }
+    const found = Launcher.getFirstInstallation();
+    if (!found) {
+        return 'Browser engine unavailable: no Chrome installation found and CHROME_PATH is unset.';
+    }
+    return null;
+}

package/dist/src/oracle/client.js

@@ -1,16 +1,34 @@
-import OpenAI from 'openai';
+import OpenAI, { AzureOpenAI } from 'openai';
 import path from 'node:path';
 import { createRequire } from 'node:module';
+import { createGeminiClient } from './gemini.js';
 const CUSTOM_CLIENT_FACTORY = loadCustomClientFactory();
 export function createDefaultClientFactory() {
     if (CUSTOM_CLIENT_FACTORY) {
         return CUSTOM_CLIENT_FACTORY;
     }
-    return (key) => {
-        const instance = new OpenAI({
-            apiKey: key,
-            timeout: 20 * 60 * 1000,
-        });
+    return (key, options) => {
+        if (options?.model?.startsWith('gemini')) {
+            // Gemini client uses its own SDK; allow passing the already-resolved id for transparency/logging.
+            return createGeminiClient(key, options.model, options.resolvedModelId);
+        }
+        let instance;
+        if (options?.azure?.endpoint) {
+            instance = new AzureOpenAI({
+                apiKey: key,
+                endpoint: options.azure.endpoint,
+                apiVersion: options.azure.apiVersion,
+                deployment: options.azure.deployment,
+                timeout: 20 * 60 * 1000,
+            });
+        }
+        else {
+            instance = new OpenAI({
+                apiKey: key,
+                timeout: 20 * 60 * 1000,
+                baseURL: options?.baseUrl,
+            });
+        }
         return {
             responses: {
                 stream: (body) => instance.responses.stream(body),

package/dist/src/oracle/config.js

@@ -21,6 +21,16 @@ export const MODEL_CONFIGS = {
         },
         reasoning: { effort: 'high' },
     },
+    'gemini-3-pro': {
+        model: 'gemini-3-pro',
+        tokenizer: countTokensGpt5Pro,
+        inputLimit: 200000,
+        pricing: {
+            inputPerToken: 2 / 1_000_000,
+            outputPerToken: 12 / 1_000_000,
+        },
+        reasoning: null,
+    },
 };
 export const DEFAULT_SYSTEM_PROMPT = [
     'You are Oracle, a focused one-shot problem solver.',