@indykish/oracle 0.9.0

package/dist/src/mcp/server.js

@@ -0,0 +1,40 @@
+#!/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);
+    };
+    const closed = new Promise((resolve) => {
+        transport.onclose = () => {
+            resolve();
+        };
+    });
+    // Keep the process alive until the client closes the transport.
+    await server.connect(transport);
+    await closed;
+}
+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,290 @@
+import { z } from 'zod';
+import { getCliVersion } from '../../version.js';
+import { LoggingMessageNotificationParamsSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ensureBrowserAvailable, mapConsultToRunOptions } from '../utils.js';
+import { sessionStore } from '../../sessionStore.js';
+import { resolveRemoteServiceConfig } from '../../remote/remoteServiceConfig.js';
+import { createRemoteBrowserExecutor } from '../../remote/client.js';
+async function readSessionLogTail(sessionId, maxBytes) {
+    try {
+        const log = await sessionStore.readLog(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.')
+        .describe('User prompt to run.'),
+    files: z
+        .array(z.string())
+        .default([])
+        .describe('Optional file paths or glob patterns (like the CLI `--file`). Resolved relative to the MCP server working directory.'),
+    model: z
+        .string()
+        .optional()
+        .describe('Single model name/label. Prefer setting `engine` explicitly to avoid default surprises.'),
+    models: z
+        .array(z.string())
+        .optional()
+        .describe('Multi-model fan-out (API engine only). Cannot be combined with browser automation.'),
+    engine: z
+        .enum(['api', 'browser'])
+        .optional()
+        .describe('Execution engine. `api` uses OpenAI/other providers. `browser` automates the ChatGPT web UI (supports attachments and ChatGPT-only model labels).'),
+    browserModelLabel: z
+        .string()
+        .optional()
+        .describe('Browser-only: explicit ChatGPT UI label to select (overrides model mapping). Example: "GPT-5.2 Thinking".'),
+    browserAttachments: z
+        .enum(['auto', 'never', 'always'])
+        .optional()
+        .describe('Browser-only: how to deliver `files`. Use "always" for real ChatGPT file uploads (including images/PDFs). Use "never" to paste file contents inline. "auto" chooses based on prompt size.'),
+    browserBundleFiles: z
+        .boolean()
+        .optional()
+        .describe('Browser-only: bundle many files into a single upload (helps with upload limits).'),
+    browserThinkingTime: z
+        .enum(['light', 'standard', 'extended', 'heavy'])
+        .optional()
+        .describe('Browser-only: set ChatGPT thinking time when supported by the chosen model.'),
+    browserKeepBrowser: z
+        .boolean()
+        .optional()
+        .describe('Browser-only: keep Chrome running after completion (useful for debugging).'),
+    search: z
+        .boolean()
+        .optional()
+        .describe('API-only: enable/disable the provider search tool (browser engine ignores this).'),
+    slug: z
+        .string()
+        .optional()
+        .describe('Optional human-friendly session id (used for later `oracle sessions` lookups).'),
+};
+const consultModelSummaryShape = z.object({
+    model: z.string(),
+    status: z.string(),
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    usage: z
+        .object({
+        inputTokens: z.number().optional(),
+        outputTokens: z.number().optional(),
+        reasoningTokens: z.number().optional(),
+        totalTokens: z.number().optional(),
+        cost: z.number().optional(),
+    })
+        .optional(),
+    response: z
+        .object({
+        id: z.string().optional(),
+        requestId: z.string().optional(),
+        status: z.string().optional(),
+    })
+        .optional(),
+    error: z
+        .object({
+        category: z.string().optional(),
+        message: z.string().optional(),
+    })
+        .optional(),
+    logPath: z.string().optional(),
+});
+const consultOutputShape = {
+    sessionId: z.string(),
+    status: z.string(),
+    output: z.string(),
+    models: z.array(consultModelSummaryShape).optional(),
+};
+export function summarizeModelRunsForConsult(runs) {
+    if (!runs || runs.length === 0) {
+        return undefined;
+    }
+    return runs.map((run) => {
+        const response = run.response
+            ? {
+                id: run.response.id ?? undefined,
+                requestId: run.response.requestId ?? undefined,
+                status: run.response.status ?? undefined,
+            }
+            : undefined;
+        const error = run.error
+            ? {
+                category: run.error.category,
+                message: run.error.message,
+            }
+            : undefined;
+        return {
+            model: run.model,
+            status: run.status ?? 'unknown',
+            startedAt: run.startedAt,
+            completedAt: run.completedAt,
+            usage: run.usage,
+            response,
+            error,
+            logPath: run.log?.path,
+        };
+    });
+}
+export function registerConsultTool(server) {
+    server.registerTool('consult', {
+        title: 'Run an oracle session',
+        description: 'Run a one-shot Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. For browser-based image/file uploads, set `browserAttachments:"always"`. Sessions are stored under `ORACLE_HOME_DIR` (shared with the CLI).',
+        // 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, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserThinkingTime, browserKeepBrowser, slug, } = consultInputSchema.parse(input);
+        const { config: userConfig } = await loadUserConfig();
+        const { runOptions, resolvedEngine } = mapConsultToRunOptions({
+            prompt,
+            files: files ?? [],
+            model,
+            models,
+            engine,
+            search,
+            browserAttachments,
+            browserBundleFiles,
+            userConfig,
+            env: process.env,
+        });
+        const cwd = process.cwd();
+        const resolvedRemote = resolveRemoteServiceConfig({ userConfig, env: process.env });
+        const browserGuard = ensureBrowserAvailable(resolvedEngine, { remoteHost: resolvedRemote.host });
+        if (resolvedEngine === 'browser' && browserGuard) {
+            return {
+                isError: true,
+                content: textContent(browserGuard),
+            };
+        }
+        let browserDeps;
+        if (resolvedEngine === 'browser' && resolvedRemote.host) {
+            if (!resolvedRemote.token) {
+                return {
+                    isError: true,
+                    content: textContent(`Remote host configured (${resolvedRemote.host}) but remote token is missing. Run \`oracle bridge client --connect <...>\` or set ORACLE_REMOTE_TOKEN.`),
+                };
+            }
+            browserDeps = {
+                executeBrowser: createRemoteBrowserExecutor({ host: resolvedRemote.host, token: resolvedRemote.token }),
+            };
+        }
+        let browserConfig;
+        if (resolvedEngine === 'browser') {
+            const envProfileDir = (process.env.ORACLE_BROWSER_PROFILE_DIR ?? '').trim();
+            const hasProfileDir = envProfileDir.length > 0;
+            const preferredLabel = (browserModelLabel ?? model)?.trim();
+            const isChatGptModel = runOptions.model.startsWith('gpt-') && !runOptions.model.includes('codex');
+            const desiredModelLabel = isChatGptModel
+                ? mapModelToBrowserLabel(runOptions.model)
+                : resolveBrowserModelLabel(preferredLabel, runOptions.model);
+            const configuredUrl = userConfig.browser?.chatgptUrl ?? userConfig.browser?.url ?? undefined;
+            // Default to manual-login when a persistent profile dir is provided (common for Codex/Claude).
+            const manualLogin = hasProfileDir;
+            browserConfig = {
+                url: configuredUrl ?? CHATGPT_URL,
+                cookieSync: !manualLogin,
+                headless: false,
+                hideWindow: false,
+                keepBrowser: browserKeepBrowser ?? false,
+                manualLogin,
+                manualLoginProfileDir: manualLogin ? envProfileDir : null,
+                thinkingTime: browserThinkingTime,
+                desiredModel: desiredModelLabel || mapModelToBrowserLabel(runOptions.model),
+            };
+        }
+        const notifications = resolveNotificationSettings({
+            cliNotify: undefined,
+            cliNotifySound: undefined,
+            env: process.env,
+            config: userConfig.notify,
+        });
+        const sessionMeta = await sessionStore.createSession({
+            ...runOptions,
+            mode: resolvedEngine,
+            slug,
+            browserConfig,
+            waitPreference: true,
+        }, cwd, notifications);
+        const logWriter = sessionStore.createLogWriter(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,
+                muteStdout: true,
+                browserDeps,
+            });
+        }
+        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 sessionStore.readSession(sessionMeta.id)) ?? sessionMeta;
+            const summary = `Session ${sessionMeta.id} (${finalMeta.status})`;
+            const logTail = await readSessionLogTail(sessionMeta.id, 4000);
+            const modelsSummary = summarizeModelRunsForConsult(finalMeta.models);
+            return {
+                content: textContent([summary, logTail || '(log empty)'].join('\n').trim()),
+                structuredContent: {
+                    sessionId: sessionMeta.id,
+                    status: finalMeta.status,
+                    output: logTail ?? '',
+                    models: modelsSummary,
+                },
+            };
+        }
+        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,75 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import fs from 'node:fs/promises';
+import { sessionStore } from '../../sessionStore.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');
+        }
+        switch (kind) {
+            case 'metadata': {
+                const metadata = await sessionStore.readSession(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 sessionStore.readLog(id);
+                return {
+                    contents: [
+                        {
+                            uri: uri.href,
+                            text: log,
+                        },
+                    ],
+                };
+            }
+            case 'request': {
+                const request = await sessionStore.readRequest(id);
+                if (request) {
+                    return {
+                        contents: [
+                            {
+                                uri: uri.href,
+                                text: JSON.stringify(request, null, 2),
+                            },
+                        ],
+                    };
+                }
+                const paths = await sessionStore.getPaths(id);
+                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,105 @@
+import { z } from 'zod';
+import { sessionStore } from '../../sessionStore.js';
+import { sessionsInputSchema } from '../types.js';
+const sessionsInputShape = {
+    id: z
+        .string()
+        .optional()
+        .describe('Session id or slug. If set, returns a single session (use detail:true to include metadata/request).'),
+    hours: z.number().optional().describe('Look back this many hours when listing sessions (default: 24).'),
+    limit: z.number().optional().describe('Maximum sessions to return when listing (default: 100).'),
+    includeAll: z
+        .boolean()
+        .optional()
+        .describe('Include sessions outside the time window when listing (mirrors `oracle status --all`).'),
+    detail: z
+        .boolean()
+        .optional()
+        .describe('When id is set, include session metadata + stored request + full log text.'),
+};
+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: 'Inspect Oracle session history stored under `ORACLE_HOME_DIR` (shared with the CLI). List recent sessions or fetch one by id/slug (optionally including metadata + request + log).',
+        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 sessionStore.readSession(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 sessionStore.readSession(id);
+            if (!metadata) {
+                throw new Error(`Session "${id}" not found.`);
+            }
+            const log = await sessionStore.readLog(id);
+            const request = (await sessionStore.readRequest(id)) ?? undefined;
+            return {
+                content: textContent(log),
+                structuredContent: { session: { metadata, log, request } },
+            };
+        }
+        const metas = await sessionStore.listSessions();
+        const { entries, truncated, total } = sessionStore.filterSessions(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,22 @@
+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(),
+    models: z.array(z.string()).optional(),
+    engine: z.enum(['api', 'browser']).optional(),
+    browserModelLabel: z.string().optional(),
+    browserAttachments: z.enum(['auto', 'never', 'always']).optional(),
+    browserBundleFiles: z.boolean().optional(),
+    browserThinkingTime: z.enum(['light', 'standard', 'extended', 'heavy']).optional(),
+    browserKeepBrowser: z.boolean().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,37 @@
+import { resolveRunOptionsFromConfig } from '../cli/runOptions.js';
+import { Launcher } from 'chrome-launcher';
+export function mapConsultToRunOptions({ prompt, files, model, models, engine, search, browserAttachments, browserBundleFiles, 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 mergedModels = Array.isArray(models) && models.length > 0
+        ? [model, ...models].filter((entry) => Boolean(entry?.trim()))
+        : models;
+    const result = resolveRunOptionsFromConfig({ prompt, files, model, models: mergedModels, engine, userConfig, env });
+    if (typeof search === 'boolean') {
+        result.runOptions.search = search;
+    }
+    if (browserAttachments) {
+        result.runOptions.browserAttachments = browserAttachments;
+    }
+    if (typeof browserBundleFiles === 'boolean') {
+        result.runOptions.browserBundleFiles = browserBundleFiles;
+    }
+    return result;
+}
+export function ensureBrowserAvailable(engine, options) {
+    if (engine !== 'browser') {
+        return null;
+    }
+    const remoteHost = options?.remoteHost?.trim() || process.env.ORACLE_REMOTE_HOST?.trim();
+    if (remoteHost) {
+        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;
+}