@steipete/oracle 0.9.0 → 0.11.0

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

@@ -1,10 +1,10 @@
-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';
+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);
@@ -17,62 +17,85 @@ async function readSessionLogTail(sessionId, maxBytes) {
         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';
+import { performSessionRun } from "../../cli/sessionRunner.js";
+import { runDryRunSummary } from "../../cli/dryRun.js";
+import { CHATGPT_URL } from "../../browser/constants.js";
+import { CONSULT_PRESETS, consultInputSchema } from "../types.js";
+import { applyConsultPreset } from "../consultPresets.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.'),
+    preset: z
+        .enum(CONSULT_PRESETS)
+        .optional()
+        .describe('Optional MCP convenience preset. "chatgpt-pro-heavy" selects ChatGPT browser mode, the current Pro model alias, and Pro Extended thinking unless overridden.'),
+    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.'),
+        .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.'),
+        .describe("Single model name/label. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then `api` when OPENAI_API_KEY is set, otherwise `browser`. 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.'),
+        .describe("Multi-model fan-out (API engine only). Cannot be combined with browser automation."),
     engine: z
-        .enum(['api', 'browser'])
+        .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).'),
+        .describe("Execution engine. `api` uses OpenAI/other providers. `browser` automates the ChatGPT web UI (supports attachments and ChatGPT-only model labels). When omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then `api` when OPENAI_API_KEY is set, otherwise `browser`."),
     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'])
+        .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).'),
+        .describe("Browser-only: bundle many files into a single upload (helps with upload limits)."),
     browserThinkingTime: z
-        .enum(['light', 'standard', 'extended', 'heavy'])
+        .enum(["light", "standard", "extended", "heavy"])
+        .optional()
+        .describe("Browser-only: set ChatGPT thinking time when supported by the chosen model."),
+    browserModelStrategy: z
+        .enum(["select", "current", "ignore"])
         .optional()
-        .describe('Browser-only: set ChatGPT thinking time when supported by the chosen model.'),
+        .describe("Browser-only: model picker strategy. Mirrors the CLI --browser-model-strategy flag."),
+    browserResearchMode: z
+        .enum(["deep"])
+        .optional()
+        .describe("Browser-only: activate ChatGPT Deep Research mode for broad web research."),
+    browserArchive: z
+        .enum(["auto", "always", "never"])
+        .optional()
+        .describe('Browser-only: archive completed ChatGPT conversations after local artifacts are saved. "auto" archives successful non-project one-shots only.'),
+    browserFollowUps: z
+        .array(z.string())
+        .optional()
+        .describe("Browser-only: additional prompts to submit sequentially in the same ChatGPT conversation after the initial answer."),
     browserKeepBrowser: z
         .boolean()
         .optional()
-        .describe('Browser-only: keep Chrome running after completion (useful for debugging).'),
+        .describe("Browser-only: keep Chrome running after completion (useful for debugging)."),
+    dryRun: z
+        .boolean()
+        .optional()
+        .describe("Preview the resolved Oracle run without creating a session or touching the browser."),
     search: z
         .boolean()
         .optional()
-        .describe('API-only: enable/disable the provider search tool (browser engine ignores this).'),
+        .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).'),
+        .describe("Optional human-friendly session id (used for later `oracle sessions` lookups)."),
 };
 const consultModelSummaryShape = z.object({
     model: z.string(),
@@ -103,10 +126,34 @@ const consultModelSummaryShape = z.object({
         .optional(),
     logPath: z.string().optional(),
 });
+const consultDryRunResolvedShape = z.object({
+    resolvedEngine: z.enum(["api", "browser"]),
+    model: z.string(),
+    models: z.array(z.string()).optional(),
+    files: z.array(z.string()),
+    followUpCount: z.number(),
+    browser: z
+        .object({
+        desiredModel: z.string().nullable().optional(),
+        thinkingTime: z.string().nullable().optional(),
+        modelStrategy: z.string().nullable().optional(),
+        researchMode: z.string().nullable().optional(),
+        attachments: z.string().optional(),
+        bundleFiles: z.boolean().optional(),
+        keepBrowser: z.boolean().optional(),
+        manualLogin: z.boolean().optional(),
+        profileDir: z.string().nullable().optional(),
+        chatgptUrl: z.string().nullable().optional(),
+    })
+        .optional(),
+    guidance: z.array(z.string()),
+});
 const consultOutputShape = {
-    sessionId: z.string(),
+    sessionId: z.string().optional(),
     status: z.string(),
     output: z.string(),
+    dryRun: z.boolean().optional(),
+    resolved: consultDryRunResolvedShape.optional(),
     models: z.array(consultModelSummaryShape).optional(),
 };
 export function summarizeModelRunsForConsult(runs) {
@@ -129,7 +176,7 @@ export function summarizeModelRunsForConsult(runs) {
             : undefined;
         return {
             model: run.model,
-            status: run.status ?? 'unknown',
+            status: run.status ?? "unknown",
             startedAt: run.startedAt,
             completedAt: run.completedAt,
             usage: run.usage,
@@ -139,17 +186,17 @@ export function summarizeModelRunsForConsult(runs) {
         };
     });
 }
-export function buildConsultBrowserConfig({ userConfig, env, runModel, inputModel, browserModelLabel, browserThinkingTime, browserKeepBrowser, }) {
+export function buildConsultBrowserConfig({ userConfig, env, runModel, inputModel, browserModelLabel, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserKeepBrowser, }) {
     const configuredBrowser = userConfig.browser ?? {};
-    const envProfileDir = (env.ORACLE_BROWSER_PROFILE_DIR ?? '').trim();
+    const envProfileDir = (env.ORACLE_BROWSER_PROFILE_DIR ?? "").trim();
     const hasProfileDir = envProfileDir.length > 0;
     const preferredLabel = (browserModelLabel ?? inputModel)?.trim();
-    const isChatGptModel = runModel.startsWith('gpt-') && !runModel.includes('codex');
+    const isChatGptModel = runModel.startsWith("gpt-") && !runModel.includes("codex");
     const desiredModelLabel = isChatGptModel
         ? mapModelToBrowserLabel(runModel)
         : resolveBrowserModelLabel(preferredLabel, runModel);
     const configuredUrl = configuredBrowser.chatgptUrl ?? configuredBrowser.url ?? CHATGPT_URL;
-    const manualLogin = hasProfileDir ? true : configuredBrowser.manualLogin ?? false;
+    const manualLogin = hasProfileDir ? true : (configuredBrowser.manualLogin ?? false);
     return {
         ...configuredBrowser,
         url: configuredUrl,
@@ -159,21 +206,112 @@ export function buildConsultBrowserConfig({ userConfig, env, runModel, inputMode
         hideWindow: configuredBrowser.hideWindow ?? false,
         keepBrowser: browserKeepBrowser ?? configuredBrowser.keepBrowser ?? false,
         manualLogin,
-        manualLoginProfileDir: manualLogin ? ((envProfileDir || configuredBrowser.manualLoginProfileDir) ?? null) : null,
+        manualLoginProfileDir: manualLogin
+            ? ((envProfileDir || configuredBrowser.manualLoginProfileDir) ?? null)
+            : null,
         thinkingTime: browserThinkingTime ?? configuredBrowser.thinkingTime,
+        modelStrategy: browserModelStrategy ?? configuredBrowser.modelStrategy,
+        researchMode: browserResearchMode ?? configuredBrowser.researchMode,
+        archiveConversations: browserArchive ?? configuredBrowser.archiveConversations,
         desiredModel: desiredModelLabel || mapModelToBrowserLabel(runModel),
     };
 }
+export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browserConfig, }) {
+    const guidance = [];
+    const followUpCount = runOptions.browserFollowUps?.filter((entry) => entry.trim()).length ?? 0;
+    if (resolvedEngine === "api") {
+        guidance.push('API engine requires provider credentials. If the operator has ChatGPT Pro but no API key, retry with engine:"browser" or preset:"chatgpt-pro-heavy".');
+    }
+    if (resolvedEngine === "browser") {
+        guidance.push("Browser engine uses the signed-in ChatGPT profile; run dryRun:true before live use.");
+    }
+    const desiredModel = browserConfig?.desiredModel ?? null;
+    const thinkingTime = browserConfig?.thinkingTime ?? null;
+    if (runOptions.model === "gpt-5.5-pro" && thinkingTime === "heavy") {
+        guidance.push('gpt-5.5-pro should normally use Pro Extended. Use model:"gpt-5.5" with browserThinkingTime:"heavy" only when you explicitly want Thinking Heavy.');
+    }
+    const chatgptUrl = browserConfig?.chatgptUrl ?? browserConfig?.url ?? null;
+    if (chatgptUrl?.includes("/project")) {
+        guidance.push("This ChatGPT project URL is persistent. Project Sources should be mutated only by the project_sources tool with confirmMutation:true.");
+    }
+    if (followUpCount > 0) {
+        guidance.push("This is a multi-turn browser consult; all follow-ups stay in one ChatGPT conversation.");
+    }
+    return {
+        resolvedEngine,
+        model: runOptions.model,
+        models: runOptions.models,
+        files: runOptions.file ?? [],
+        followUpCount,
+        browser: resolvedEngine === "browser"
+            ? {
+                desiredModel,
+                thinkingTime,
+                modelStrategy: browserConfig?.modelStrategy ?? null,
+                researchMode: browserConfig?.researchMode ?? null,
+                attachments: runOptions.browserAttachments,
+                bundleFiles: runOptions.browserBundleFiles,
+                keepBrowser: browserConfig?.keepBrowser,
+                manualLogin: browserConfig?.manualLogin,
+                profileDir: browserConfig?.manualLoginProfileDir ?? null,
+                chatgptUrl,
+            }
+            : undefined,
+        guidance,
+    };
+}
+export function formatConsultDryRunResolved(details) {
+    const lines = [
+        "[dry-run] MCP resolved request:",
+        `  engine: ${details.resolvedEngine}`,
+        `  model: ${details.model}`,
+    ];
+    if (details.models && details.models.length > 0) {
+        lines.push(`  models: ${details.models.join(", ")}`);
+    }
+    lines.push(`  files: ${details.files.length}`);
+    if (details.browser) {
+        lines.push(`  browser desired model: ${details.browser.desiredModel ?? "(default)"}`);
+        lines.push(`  browser thinking time: ${details.browser.thinkingTime ?? "(default)"}`);
+        lines.push(`  browser model strategy: ${details.browser.modelStrategy ?? "(default)"}`);
+        lines.push(`  browser research mode: ${details.browser.researchMode ?? "off"}`);
+        lines.push(`  browser attachments: ${details.browser.attachments ?? "auto"}`);
+        lines.push(`  browser bundle files: ${details.browser.bundleFiles ? "yes" : "no"}`);
+        lines.push(`  browser keep browser: ${details.browser.keepBrowser ? "yes" : "no"}`);
+        lines.push(`  browser manual login: ${details.browser.manualLogin ? "yes" : "no"}`);
+        if (details.browser.profileDir) {
+            lines.push(`  browser profile: ${details.browser.profileDir}`);
+        }
+        if (details.browser.chatgptUrl) {
+            lines.push(`  ChatGPT URL: ${details.browser.chatgptUrl}`);
+        }
+    }
+    lines.push(`  follow-ups: ${details.followUpCount}`);
+    for (const guidance of details.guidance) {
+        lines.push(`  guidance: ${guidance}`);
+    }
+    return lines;
+}
 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).',
+    server.registerTool("consult", {
+        title: "Run an oracle session",
+        description: 'Run an Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then API when OPENAI_API_KEY is set, otherwise browser. Browser GPT-5.5 Pro consults can take many minutes; use `dryRun:true` first when configuring an agent and inspect `sessions`/`oracle status` before retrying. For browser-based image/file uploads, set `browserAttachments:"always"`. Browser consults can include `browserFollowUps` for a multi-turn ChatGPT review in one conversation. 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 textContent = (text) => [{ type: "text", text }];
+        let parsedInput;
+        try {
+            parsedInput = applyConsultPreset(consultInputSchema.parse(input));
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: textContent(error instanceof Error ? error.message : String(error)),
+            };
+        }
+        const { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserFollowUps, browserKeepBrowser, dryRun, slug, } = parsedInput;
         const { config: userConfig } = await loadUserConfig();
         const { runOptions, resolvedEngine } = mapConsultToRunOptions({
             prompt,
@@ -184,20 +322,77 @@ export function registerConsultTool(server) {
             search,
             browserAttachments,
             browserBundleFiles,
+            browserFollowUps,
             userConfig,
             env: process.env,
         });
         const cwd = process.cwd();
+        const sendLog = (text, level = "info") => server.server
+            .sendLoggingMessage(LoggingMessageNotificationParamsSchema.parse({
+            level,
+            data: { text, bytes: Buffer.byteLength(text, "utf8") },
+        }))
+            .catch(() => { });
         const resolvedRemote = resolveRemoteServiceConfig({ userConfig, env: process.env });
-        const browserGuard = ensureBrowserAvailable(resolvedEngine, { remoteHost: resolvedRemote.host });
-        if (resolvedEngine === 'browser' && browserGuard) {
+        let browserConfig;
+        if (resolvedEngine === "browser") {
+            browserConfig = buildConsultBrowserConfig({
+                userConfig,
+                env: process.env,
+                runModel: runOptions.model,
+                inputModel: model,
+                browserModelLabel,
+                browserThinkingTime,
+                browserModelStrategy,
+                browserResearchMode,
+                browserArchive,
+                browserKeepBrowser,
+            });
+        }
+        if (dryRun) {
+            const lines = [];
+            const log = (line) => {
+                lines.push(line);
+                sendLog(line);
+            };
+            const resolved = buildConsultDryRunResolved({
+                resolvedEngine,
+                runOptions,
+                browserConfig,
+            });
+            await runDryRunSummary({
+                engine: resolvedEngine,
+                runOptions,
+                cwd,
+                version: getCliVersion(),
+                log,
+                browserConfig,
+            });
+            for (const line of formatConsultDryRunResolved(resolved)) {
+                log(line);
+            }
+            const output = lines.join("\n").trim();
+            return {
+                content: textContent(output),
+                structuredContent: {
+                    status: "dry-run",
+                    output,
+                    dryRun: true,
+                    resolved,
+                },
+            };
+        }
+        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 (resolvedEngine === "browser" && resolvedRemote.host) {
             if (!resolvedRemote.token) {
                 return {
                     isError: true,
@@ -205,21 +400,12 @@ export function registerConsultTool(server) {
                 };
             }
             browserDeps = {
-                executeBrowser: createRemoteBrowserExecutor({ host: resolvedRemote.host, token: resolvedRemote.token }),
+                executeBrowser: createRemoteBrowserExecutor({
+                    host: resolvedRemote.host,
+                    token: resolvedRemote.token,
+                }),
             };
         }
-        let browserConfig;
-        if (resolvedEngine === 'browser') {
-            browserConfig = buildConsultBrowserConfig({
-                userConfig,
-                env: process.env,
-                runModel: runOptions.model,
-                inputModel: model,
-                browserModelLabel,
-                browserThinkingTime,
-                browserKeepBrowser,
-            });
-        }
         const notifications = resolveNotificationSettings({
             cliNotify: undefined,
             cliNotifySound: undefined,
@@ -234,13 +420,6 @@ export function registerConsultTool(server) {
             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);
@@ -250,7 +429,7 @@ export function registerConsultTool(server) {
         };
         const write = (chunk) => {
             logWriter.writeChunk(chunk);
-            sendLog(chunk, 'debug');
+            sendLog(chunk, "debug");
             return true;
         };
         try {
@@ -284,11 +463,11 @@ export function registerConsultTool(server) {
             const logTail = await readSessionLogTail(sessionMeta.id, 4000);
             const modelsSummary = summarizeModelRunsForConsult(finalMeta.models);
             return {
-                content: textContent([summary, logTail || '(log empty)'].join('\n').trim()),
+                content: textContent([summary, logTail || "(log empty)"].join("\n").trim()),
                 structuredContent: {
                     sessionId: sessionMeta.id,
                     status: finalMeta.status,
-                    output: logTail ?? '',
+                    output: logTail ?? "",
                     models: modelsSummary,
                 },
             };

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

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import { loadUserConfig } from "../../config.js";
+import { resolveRemoteServiceConfig } from "../../remote/remoteServiceConfig.js";
+import { runBrowserProjectSources } from "../../browser/projectSourcesRunner.js";
+import { normalizeProjectSourcesUrl } from "../../projectSources/url.js";
+import { buildProjectSourcesBrowserConfig, resolveProjectSourceFiles, } from "../../cli/projectSources.js";
+import { resolveConfiguredMaxFileSizeBytes } from "../../cli/fileSize.js";
+const projectSourceEntryShape = z.object({
+    name: z.string(),
+    index: z.number(),
+    status: z.enum(["ready", "processing", "unknown"]).optional(),
+});
+const projectSourceUploadPlanShape = z.object({
+    path: z.string(),
+    displayPath: z.string(),
+    name: z.string(),
+    sizeBytes: z.number().optional(),
+    batch: z.number(),
+});
+const projectSourcesInputShape = {
+    operation: z
+        .enum(["list", "add"])
+        .describe("Project Sources operation. v1 intentionally supports only non-destructive list/add."),
+    chatgptUrl: z
+        .string()
+        .optional()
+        .describe("ChatGPT project URL ending in /project. Falls back to browser.chatgptUrl config."),
+    files: z
+        .array(z.string())
+        .default([])
+        .describe("Local file paths or globs to add as persistent ChatGPT Project Sources."),
+    dryRun: z
+        .boolean()
+        .optional()
+        .describe("Validate files and return an upload plan without touching the browser."),
+    confirmMutation: z
+        .boolean()
+        .optional()
+        .describe("Required for mutating add operations so agents do not modify project state accidentally."),
+    browserKeepBrowser: z.boolean().optional().describe("Keep Chrome running after completion."),
+};
+const projectSourcesOutputShape = {
+    status: z.enum(["ok", "dry-run"]),
+    operation: z.enum(["list", "add"]),
+    projectUrl: z.string(),
+    dryRun: z.boolean(),
+    sourcesBefore: z.array(projectSourceEntryShape).optional(),
+    sourcesAfter: z.array(projectSourceEntryShape).optional(),
+    plannedUploads: z.array(projectSourceUploadPlanShape).optional(),
+    added: z.array(projectSourceEntryShape).optional(),
+    warnings: z.array(z.string()),
+    tookMs: z.number(),
+};
+const projectSourcesInputSchema = z.object(projectSourcesInputShape);
+export function registerProjectSourcesTool(server) {
+    server.registerTool("project_sources", {
+        title: "Manage ChatGPT Project Sources",
+        description: "List or append files to a ChatGPT Project's persistent Sources tab. This is useful for Developer Mode workflows where chats do not share memory, but explicit project sources provide shared context. Destructive delete/replace/sync operations are intentionally not included in v1.",
+        inputSchema: projectSourcesInputShape,
+        outputSchema: projectSourcesOutputShape,
+    }, async (input) => {
+        const textContent = (text) => [{ type: "text", text }];
+        let parsed;
+        try {
+            parsed = projectSourcesInputSchema.parse(input);
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: textContent(error instanceof Error ? error.message : String(error)),
+            };
+        }
+        const { config: userConfig } = await loadUserConfig();
+        const resolvedRemote = resolveRemoteServiceConfig({ userConfig, env: process.env });
+        if (resolvedRemote.host) {
+            return {
+                isError: true,
+                content: textContent("project_sources v1 must run on the signed-in browser host; remote oracle serve support is not enabled yet."),
+            };
+        }
+        const projectUrl = normalizeProjectSourcesUrl(parsed.chatgptUrl ?? userConfig.browser?.chatgptUrl ?? userConfig.browser?.url ?? "");
+        if (parsed.operation === "add" && !parsed.dryRun && parsed.confirmMutation !== true) {
+            return {
+                isError: true,
+                content: textContent("project_sources add modifies persistent ChatGPT Project Sources. Retry with `confirmMutation: true` or use `dryRun: true` first."),
+            };
+        }
+        const maxFileSizeBytes = resolveConfiguredMaxFileSizeBytes(userConfig, process.env);
+        const files = parsed.operation === "add"
+            ? await resolveProjectSourceFiles(parsed.files ?? [], {
+                cwd: process.cwd(),
+                maxFileSizeBytes,
+            })
+            : [];
+        const browserConfig = await buildProjectSourcesBrowserConfig({
+            options: {
+                chatgptUrl: projectUrl,
+                browserKeepBrowser: parsed.browserKeepBrowser,
+            },
+            projectUrl,
+            configuredBrowser: userConfig.browser ?? {},
+        });
+        const result = await runBrowserProjectSources({
+            operation: parsed.operation,
+            chatgptUrl: projectUrl,
+            files,
+            dryRun: parsed.dryRun,
+            config: browserConfig,
+            log: (message) => {
+                server.server
+                    .sendLoggingMessage({ level: "info", data: { text: message } })
+                    .catch(() => undefined);
+            },
+        });
+        const output = result.status === "dry-run"
+            ? `Project Sources ${result.operation} dry run: ${result.plannedUploads?.length ?? 0} planned upload(s).`
+            : `Project Sources ${result.operation} completed: ${result.sourcesAfter?.length ?? 0} source(s).`;
+        return {
+            content: textContent(output),
+            structuredContent: result,
+        };
+    });
+}

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

@@ -1,15 +1,15 @@
-import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-import fs from 'node:fs/promises';
-import { sessionStore } from '../../sessionStore.js';
+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.',
+    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;
@@ -17,10 +17,10 @@ export function registerSessionResources(server) {
         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');
+            throw new Error("Missing id or kind");
         }
         switch (kind) {
-            case 'metadata': {
+            case "metadata": {
                 const metadata = await sessionStore.readSession(id);
                 if (!metadata) {
                     throw new Error(`Session "${id}" not found.`);
@@ -34,7 +34,7 @@ export function registerSessionResources(server) {
                     ],
                 };
             }
-            case 'log': {
+            case "log": {
                 const log = await sessionStore.readLog(id);
                 return {
                     contents: [
@@ -45,7 +45,7 @@ export function registerSessionResources(server) {
                     ],
                 };
             }
-            case 'request': {
+            case "request": {
                 const request = await sessionStore.readRequest(id);
                 if (request) {
                     return {
@@ -58,7 +58,7 @@ export function registerSessionResources(server) {
                     };
                 }
                 const paths = await sessionStore.getPaths(id);
-                const raw = await fs.readFile(paths.request, 'utf8');
+                const raw = await fs.readFile(paths.request, "utf8");
                 return {
                     contents: [
                         {