@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/mcp/mcp-server.js

@@ -1,543 +1,513 @@
 /**
- * MCP Server - Expose Code Buddy tools via the Model Context Protocol
+ * MCP Server - expose Code Buddy's real tool registry over stdio.
  *
- * Allows Code Buddy to act as a tool provider for other AI agents
- * (VS Code, Cursor, Claude Desktop, etc.) over stdio transport.
- *
- * Exposed tools (15 total):
- * - read_file: Read file contents
- * - write_file: Write/create a file
- * - edit_file: String replacement editing
- * - bash: Execute shell commands
- * - search_files: Search file contents (ripgrep-based)
- * - list_files: List directory contents
- * - git: Git operations (status, diff, log, add, commit, etc.)
- * - agent_chat: AI-powered chat with tool execution
- * - agent_task: Autonomous task execution
- * - agent_plan: Create execution plan
- * - memory_search: Search semantic memory
- * - memory_save: Save persistent memory
- * - session_list: List recent sessions
- * - session_resume: Resume previous session
- * - web_search: Web search via configured providers
- *
- * Resources (4):
- * - codebuddy://project/context
- * - codebuddy://project/instructions
- * - codebuddy://sessions/latest
- * - codebuddy://memory/all
- *
- * Prompts (5):
- * - code_review, explain_code, generate_tests, refactor, fix_bugs
+ * The registry's `fleetSafe: true` metadata is the default allowlist. Tools
+ * without that audited read-only contract are only registered after an
+ * explicit `--allow-write` / `CODEBUDDY_MCP_ALLOW_WRITE=1` opt-in.
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
-import * as path from 'path';
-import * as fs from 'fs';
+import { initializeToolRegistry } from '../codebuddy/tools.js';
+import { getToolRegistry } from '../tools/registry.js';
+import { createInteractiveToolAdapters } from '../tools/registry/interactive-adapters.js';
+import { getFormalToolRegistry } from '../tools/registry/tool-registry.js';
+import { matchAnyGlob } from '../utils/glob-matcher.js';
+import { logger } from '../utils/logger.js';
+import { ConfirmationService } from '../utils/confirmation-service.js';
+import { createMcpApprovalBridge } from '../server/mcp/approval-elicitation.js';
 import { registerAgentTools } from './mcp-agent-tools.js';
+import { registerCkgTools } from './mcp-ckg-tools.js';
+import { desktopControlEnabled, registerDesktopTools, } from './mcp-desktop-tools.js';
 import { registerMemoryTools } from './mcp-memory-tools.js';
-import { registerSessionTools } from './mcp-session-tools.js';
-import { registerDesktopTools } from './mcp-desktop-tools.js';
-import { registerResources } from './mcp-resources.js';
 import { registerPrompts } from './mcp-prompts.js';
-// Read version from package.json (avoid import.meta.url for ts-jest compat)
-let packageVersion = '0.1.0';
-try {
-    const pkgPath = path.resolve(__dirname, '../../package.json');
-    const pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-    packageVersion = pkgJson.version || packageVersion;
+import { registerResources } from './mcp-resources.js';
+import { registerSessionTools } from './mcp-session-tools.js';
+const PACKAGE_VERSION_FALLBACK = '0.1.0';
+const WRITE_ENV = 'CODEBUDDY_MCP_ALLOW_WRITE';
+const TOOLS_ENV = 'CODEBUDDY_MCP_TOOLS';
+function readPackageVersion() {
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const packagePath = path.resolve(currentDir, '../../package.json');
+        const parsed = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        return typeof parsed.version === 'string' ? parsed.version : PACKAGE_VERSION_FALLBACK;
+    }
+    catch {
+        return PACKAGE_VERSION_FALLBACK;
+    }
 }
-catch {
-    // Ignore - use default version
+function envFlagEnabled(value) {
+    return ['1', 'true', 'yes', 'on'].includes(value?.trim().toLowerCase() ?? '');
+}
+function resolveAllowWrite(explicit) {
+    return explicit ?? envFlagEnabled(process.env[WRITE_ENV]);
+}
+function splitPatternList(value) {
+    const patterns = [];
+    let start = 0;
+    let depth = 0;
+    for (let index = 0; index < value.length; index++) {
+        const character = value[index];
+        if (character === '{' || character === '[')
+            depth++;
+        else if (character === '}' || character === ']')
+            depth = Math.max(0, depth - 1);
+        else if (character === ',' && depth === 0) {
+            patterns.push(value.slice(start, index));
+            start = index + 1;
+        }
+    }
+    patterns.push(value.slice(start));
+    return patterns;
+}
+function parseToolPatterns(value) {
+    const source = value === undefined ? process.env[TOOLS_ENV] : value;
+    const values = Array.isArray(source) ? source : source ? [source] : [];
+    return values
+        .flatMap(splitPatternList)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function safeAdapterMetadata(adapter) {
+    try {
+        return adapter.getMetadata?.();
+    }
+    catch {
+        return undefined;
+    }
+}
+function adapterIsAvailable(adapter) {
+    try {
+        return adapter.isAvailable?.() ?? true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildRegistryCatalog(allowWrite, patterns) {
+    initializeToolRegistry();
+    const schemaRegistry = getToolRegistry();
+    const adapters = new Map();
+    // Persisted authored tools can already be present in the formal registry.
+    for (const registered of getFormalToolRegistry().getAll()) {
+        adapters.set(registered.tool.name, registered.tool);
+    }
+    // Fresh built-in adapters avoid sharing mutable execution state with an
+    // unrelated in-process agent while retaining exactly the production surface.
+    for (const adapter of createInteractiveToolAdapters()) {
+        adapters.set(adapter.name, adapter);
+    }
+    const candidates = [];
+    const seen = new Set();
+    for (const tool of schemaRegistry.getAllTools()) {
+        const name = tool.function.name;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        const registered = schemaRegistry.getTool(name);
+        if (!registered)
+            continue;
+        let enabled = false;
+        try {
+            enabled = registered.isEnabled();
+        }
+        catch (error) {
+            logger.debug(`MCP skipped tool whose availability check failed: ${name}`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        if (!enabled)
+            continue;
+        const adapter = adapters.get(name);
+        if (!adapter) {
+            logger.debug(`MCP skipped schema without an executable registry adapter: ${name}`);
+            continue;
+        }
+        if (!adapterIsAvailable(adapter))
+            continue;
+        const adapterMetadata = safeAdapterMetadata(adapter);
+        const fleetSafe = registered.metadata.fleetSafe === true;
+        const readOnly = fleetSafe && adapterMetadata?.modifiesFiles !== true;
+        candidates.push({
+            definition: {
+                name,
+                description: tool.function.description || registered.metadata.description || adapter.description,
+                inputSchema: tool.function.parameters,
+                readOnly,
+            },
+            adapter,
+            metadata: adapterMetadata,
+        });
+    }
+    // Some production adapters (notably apply_patch and canonical aliases) have
+    // their schema on ITool#getSchema rather than in the legacy LLM registry.
+    // Include those in write-enabled mode without duplicating either source.
+    for (const [name, adapter] of adapters) {
+        if (seen.has(name) || !adapterIsAvailable(adapter))
+            continue;
+        try {
+            const schema = adapter.getSchema();
+            const adapterMetadata = safeAdapterMetadata(adapter);
+            const readOnly = adapterMetadata?.fleetSafe === true && adapterMetadata.modifiesFiles !== true;
+            candidates.push({
+                definition: {
+                    name,
+                    description: schema.description || adapterMetadata?.description || adapter.description,
+                    inputSchema: schema.parameters,
+                    readOnly,
+                },
+                adapter,
+                metadata: adapterMetadata,
+            });
+            seen.add(name);
+        }
+        catch (error) {
+            logger.debug(`MCP skipped adapter whose schema could not be read: ${name}`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    const stats = {
+        registryTotal: candidates.length,
+        registryReadOnly: candidates.filter((candidate) => candidate.definition.readOnly).length,
+    };
+    const tools = candidates
+        .filter((candidate) => allowWrite || candidate.definition.readOnly)
+        .filter((candidate) => patterns.length === 0 || matchAnyGlob(candidate.definition.name, patterns))
+        .sort((left, right) => left.definition.name.localeCompare(right.definition.name));
+    return { tools, stats };
+}
+function schemaRecord(schema) {
+    return schema && typeof schema === 'object' && !Array.isArray(schema)
+        ? schema
+        : {};
+}
+function literalSchema(value) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return z.literal(value);
+    }
+    return z.unknown();
+}
+function unionSchemas(schemas) {
+    if (schemas.length === 0)
+        return z.never();
+    if (schemas.length === 1)
+        return schemas[0];
+    return z.union(schemas);
 }
 /**
- * CodeBuddyMCPServer - MCP server that exposes Code Buddy tools.
- *
- * Usage:
- *   const server = new CodeBuddyMCPServer();
- *   await server.start();  // Blocks on stdio transport
- *   await server.stop();   // Clean shutdown
+ * Convert the registry's existing JSON Schema into the Zod schema expected by
+ * the MCP SDK. This is a mechanical bridge: descriptions, enums, object
+ * shapes, required fields, arrays and common bounds remain sourced from the
+ * canonical tool definition rather than being rewritten in this server.
  */
+function jsonSchemaToZod(input) {
+    const schema = schemaRecord(input);
+    if ('const' in schema)
+        return literalSchema(schema.const);
+    if (Array.isArray(schema.enum)) {
+        return unionSchemas(schema.enum.map(literalSchema));
+    }
+    for (const keyword of ['oneOf', 'anyOf']) {
+        const alternatives = schema[keyword];
+        if (Array.isArray(alternatives)) {
+            return unionSchemas(alternatives.map(jsonSchemaToZod));
+        }
+    }
+    if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+        const parts = schema.allOf.map(jsonSchemaToZod);
+        let intersection = parts[0];
+        for (const part of parts.slice(1)) {
+            intersection = z.intersection(intersection, part);
+        }
+        return intersection;
+    }
+    if (Array.isArray(schema.type)) {
+        return unionSchemas(schema.type.map((type) => jsonSchemaToZod({ ...schema, type })));
+    }
+    let result;
+    switch (schema.type) {
+        case 'string': {
+            let stringSchema = z.string();
+            if (typeof schema.minLength === 'number')
+                stringSchema = stringSchema.min(schema.minLength);
+            if (typeof schema.maxLength === 'number')
+                stringSchema = stringSchema.max(schema.maxLength);
+            if (typeof schema.pattern === 'string') {
+                try {
+                    stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+                }
+                catch {
+                    // The canonical tool validator remains authoritative for an invalid regex.
+                }
+            }
+            result = stringSchema;
+            break;
+        }
+        case 'integer':
+        case 'number': {
+            let numberSchema = schema.type === 'integer' ? z.number().int() : z.number();
+            if (typeof schema.minimum === 'number')
+                numberSchema = numberSchema.min(schema.minimum);
+            if (typeof schema.maximum === 'number')
+                numberSchema = numberSchema.max(schema.maximum);
+            result = numberSchema;
+            break;
+        }
+        case 'boolean':
+            result = z.boolean();
+            break;
+        case 'null':
+            result = z.null();
+            break;
+        case 'array': {
+            let arraySchema = z.array(jsonSchemaToZod(schema.items));
+            if (typeof schema.minItems === 'number')
+                arraySchema = arraySchema.min(schema.minItems);
+            if (typeof schema.maxItems === 'number')
+                arraySchema = arraySchema.max(schema.maxItems);
+            result = arraySchema;
+            break;
+        }
+        case 'object':
+        default: {
+            const properties = schemaRecord(schema.properties);
+            const required = new Set(Array.isArray(schema.required)
+                ? schema.required.filter((name) => typeof name === 'string')
+                : []);
+            const shape = {};
+            for (const [name, property] of Object.entries(properties)) {
+                const propertySchema = jsonSchemaToZod(property);
+                shape[name] = required.has(name) ? propertySchema : propertySchema.optional();
+            }
+            let objectSchema = z.object(shape);
+            if (schema.additionalProperties === false) {
+                objectSchema = objectSchema.strict();
+            }
+            else if (schema.additionalProperties &&
+                typeof schema.additionalProperties === 'object') {
+                objectSchema = objectSchema.catchall(jsonSchemaToZod(schema.additionalProperties));
+            }
+            else {
+                objectSchema = objectSchema.passthrough();
+            }
+            result = objectSchema;
+            break;
+        }
+    }
+    if (schema.nullable === true)
+        result = result.nullable();
+    if (typeof schema.description === 'string')
+        result = result.describe(schema.description);
+    return result;
+}
+function stringifyResultData(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function shouldMatchPatterns(name, patterns) {
+    return patterns.length === 0 || matchAnyGlob(name, patterns);
+}
+/** MCP server exposing the live Code Buddy registry. */
 export class CodeBuddyMCPServer {
     mcpServer;
     transport = null;
     running = false;
-    // Lazily initialized tool instances
-    textEditor = null;
-    searchTool = null;
-    gitTool = null;
-    bashTool = null;
-    // Lazily initialized agent instance
+    allowWrite;
+    patterns;
+    workingDirectory;
+    registryCatalog;
+    supplementalToolNames = [];
+    writeAccessInitialized = false;
     agent = null;
     agentInitPromise = null;
-    constructor() {
-        this.mcpServer = new McpServer({
-            name: 'code-buddy',
-            version: packageVersion,
-        }, {
-            capabilities: {
-                tools: {},
-                resources: {},
-                prompts: {},
-            },
-        });
+    constructor(options = {}) {
+        this.allowWrite = resolveAllowWrite(options.allowWrite);
+        this.patterns = parseToolPatterns(options.tools);
+        this.workingDirectory = path.resolve(options.workingDirectory ?? process.cwd());
+        this.registryCatalog = buildRegistryCatalog(this.allowWrite, this.patterns);
+        this.mcpServer = new McpServer({ name: 'code-buddy', version: readPackageVersion() }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
         this.registerTools();
         this.registerAgentLayer();
     }
-    /**
-     * Lazily initialize the CodeBuddyAgent on first use.
-     */
+    /** Definitions selected from the real registry for this exposure policy. */
+    static getToolDefinitions(options = {}) {
+        const allowWrite = resolveAllowWrite(options.allowWrite);
+        const patterns = parseToolPatterns(options.tools);
+        return buildRegistryCatalog(allowWrite, patterns).tools.map(({ definition }) => ({
+            ...definition,
+            inputSchema: { ...definition.inputSchema },
+        }));
+    }
+    /** Registry-wide counts before `--tools` narrows the exposed surface. */
+    static getToolExposureStats() {
+        return buildRegistryCatalog(true, []).stats;
+    }
+    getExposedToolDefinitions() {
+        return this.registryCatalog.tools.map(({ definition }) => ({
+            ...definition,
+            inputSchema: { ...definition.inputSchema },
+        }));
+    }
+    getExposedToolNames() {
+        return [
+            ...this.registryCatalog.tools.map(({ definition }) => definition.name),
+            ...this.supplementalToolNames,
+        ];
+    }
+    getExposureSummary() {
+        return {
+            ...this.registryCatalog.stats,
+            mode: this.allowWrite ? 'read-write' : 'read-only',
+            exposed: this.registryCatalog.tools.length + this.supplementalToolNames.length,
+            registryExposed: this.registryCatalog.tools.length,
+            supplementalExposed: this.supplementalToolNames.length,
+            patterns: [...this.patterns],
+        };
+    }
+    setupApprovalBridge() {
+        ConfirmationService.getInstance().setMcpApprovalBridge(createMcpApprovalBridge(this.mcpServer, { cwd: this.workingDirectory }));
+    }
+    async ensureWriteAccess() {
+        if (!this.allowWrite) {
+            throw new Error('Write-capable MCP tools require --allow-write');
+        }
+        if (this.writeAccessInitialized)
+            return;
+        this.setupApprovalBridge();
+        this.writeAccessInitialized = true;
+    }
     async ensureAgent() {
+        await this.ensureWriteAccess();
         if (this.agent)
             return this.agent;
         if (this.agentInitPromise)
             return this.agentInitPromise;
         this.agentInitPromise = (async () => {
-            // Resolve API key from env
-            const apiKey = process.env.GROK_API_KEY
-                || process.env.OPENAI_API_KEY
-                || process.env.ANTHROPIC_API_KEY
-                || '';
+            const { resolveActiveProviderApiKey } = await import('../config/env-schema.js');
+            const apiKey = resolveActiveProviderApiKey() || '';
             if (!apiKey) {
                 throw new Error('No API key found. Set GROK_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY.');
             }
             const { CodeBuddyAgent } = await import('../agent/codebuddy-agent.js');
-            const baseURL = process.env.GROK_BASE_URL;
-            const model = process.env.GROK_MODEL;
-            this.agent = new CodeBuddyAgent(apiKey, baseURL, model);
-            // Enable auto-approve for MCP server mode
-            const { ConfirmationService } = await import('../utils/confirmation-service.js');
-            const confirmService = ConfirmationService.getInstance();
-            confirmService.setSessionFlag('allOperations', true);
+            this.agent = new CodeBuddyAgent(apiKey, process.env.GROK_BASE_URL, process.env.GROK_MODEL);
             return this.agent;
         })();
         return this.agentInitPromise;
     }
-    /**
-     * Register agent intelligence tools, resources, and prompts.
-     * Registration modules are lightweight (just Zod schemas + handler stubs).
-     * Heavy dependencies (agent, memory, sessions) are lazy-loaded inside handlers.
-     */
     registerAgentLayer() {
-        const getAgent = () => this.ensureAgent();
-        registerAgentTools(this.mcpServer, getAgent);
-        registerMemoryTools(this.mcpServer);
-        registerSessionTools(this.mcpServer, getAgent);
-        registerDesktopTools(this.mcpServer);
+        // Resources and prompts are read-only protocol surfaces, so they remain
+        // available in both modes. Legacy MCP-only tools lack fleetSafe metadata
+        // and therefore stay behind the same explicit write-capable opt-in.
         registerResources(this.mcpServer);
         registerPrompts(this.mcpServer);
-    }
-    /**
-     * Get the list of tools exposed by this MCP server.
-     */
-    static getToolDefinitions() {
-        return [
-            {
-                name: 'read_file',
-                description: 'Read the contents of a file. Returns the file content with line numbers.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        path: { type: 'string', description: 'Absolute or relative path to the file to read' },
-                        start_line: { type: 'number', description: 'Optional start line (1-indexed)' },
-                        end_line: { type: 'number', description: 'Optional end line (1-indexed)' },
-                    },
-                    required: ['path'],
-                },
-            },
-            {
-                name: 'write_file',
-                description: 'Write content to a file. Creates the file if it does not exist, or overwrites it if it does.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        path: { type: 'string', description: 'Absolute or relative path to the file to write' },
-                        content: { type: 'string', description: 'The content to write to the file' },
-                    },
-                    required: ['path', 'content'],
-                },
-            },
-            {
-                name: 'edit_file',
-                description: 'Edit a file by replacing an exact string match with new content. The old_string must match exactly one location in the file.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        path: { type: 'string', description: 'Path to the file to edit' },
-                        old_string: { type: 'string', description: 'The exact string to find and replace' },
-                        new_string: { type: 'string', description: 'The replacement string' },
-                    },
-                    required: ['path', 'old_string', 'new_string'],
-                },
-            },
-            {
-                name: 'bash',
-                description: 'Execute a shell command and return its output. Use for running scripts, installing packages, or any terminal operation.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        command: { type: 'string', description: 'The shell command to execute' },
-                        timeout: { type: 'number', description: 'Timeout in milliseconds (default: 30000)' },
-                    },
-                    required: ['command'],
-                },
-            },
-            {
-                name: 'search_files',
-                description: 'Search for text patterns in files using ripgrep. Supports regex patterns and file type filtering.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        query: { type: 'string', description: 'The search query (text or regex pattern)' },
-                        path: { type: 'string', description: 'Directory to search in (defaults to cwd)' },
-                        include_pattern: { type: 'string', description: 'Glob pattern for files to include (e.g., "*.ts")' },
-                        case_sensitive: { type: 'boolean', description: 'Whether the search is case-sensitive (default: false)' },
-                        max_results: { type: 'number', description: 'Maximum number of results to return (default: 50)' },
-                    },
-                    required: ['query'],
-                },
-            },
-            {
-                name: 'list_files',
-                description: 'List files and directories at a given path. Returns names with type indicators (/ for directories).',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        path: { type: 'string', description: 'Directory path to list (defaults to cwd)' },
-                    },
-                    required: [],
-                },
-            },
-            {
-                name: 'git',
-                description: 'Execute git operations: status, diff, log, add, commit, branch, checkout, etc.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        subcommand: {
-                            type: 'string',
-                            description: 'Git subcommand to run',
-                            enum: ['status', 'diff', 'log', 'add', 'commit', 'branch', 'checkout'],
-                        },
-                        args: {
-                            type: 'object',
-                            description: 'Arguments for the git subcommand',
-                            properties: {
-                                files: { type: 'array', items: { type: 'string' }, description: 'Files for add/diff' },
-                                message: { type: 'string', description: 'Commit message' },
-                                staged: { type: 'boolean', description: 'Show staged changes (for diff)' },
-                                count: { type: 'number', description: 'Number of log entries' },
-                                branch_name: { type: 'string', description: 'Branch name for branch/checkout' },
-                            },
-                        },
-                    },
-                    required: ['subcommand'],
-                },
-            },
-            // Agent intelligence tools
-            {
-                name: 'agent_chat',
-                description: 'Send a message to the Code Buddy AI agent and get a response with tool call results.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        message: { type: 'string', description: 'The message to send to the agent' },
-                        mode: { type: 'string', description: 'Agent mode: code, ask, plan, architect', enum: ['code', 'ask', 'plan', 'architect'] },
-                    },
-                    required: ['message'],
-                },
-            },
-            {
-                name: 'agent_task',
-                description: 'Execute an autonomous task using Code Buddy agent with DAG-based planning for complex tasks.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        task: { type: 'string', description: 'The task to execute autonomously' },
-                        working_directory: { type: 'string', description: 'Working directory for task execution' },
-                    },
-                    required: ['task'],
-                },
-            },
-            {
-                name: 'agent_plan',
-                description: 'Create an execution plan for a task without executing it.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        task: { type: 'string', description: 'The task to plan' },
-                    },
-                    required: ['task'],
-                },
-            },
-            // Memory tools
-            {
-                name: 'memory_search',
-                description: 'Search Code Buddy\'s semantic memory for relevant stored knowledge.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        query: { type: 'string', description: 'The search query' },
-                        max_results: { type: 'number', description: 'Maximum results to return (default: 5)' },
-                    },
-                    required: ['query'],
-                },
-            },
-            {
-                name: 'memory_save',
-                description: 'Save a piece of knowledge to Code Buddy\'s persistent memory.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        key: { type: 'string', description: 'A short key/name for the memory entry' },
-                        value: { type: 'string', description: 'The content to remember' },
-                        category: { type: 'string', description: 'Memory category', enum: ['project', 'preferences', 'decisions', 'patterns', 'context', 'custom'] },
-                        scope: { type: 'string', description: 'Memory scope', enum: ['project', 'user'] },
-                    },
-                    required: ['key', 'value'],
-                },
-            },
-            // Session tools
-            {
-                name: 'session_list',
-                description: 'List recent Code Buddy chat sessions.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        count: { type: 'number', description: 'Number of recent sessions to return (default: 10)' },
-                    },
-                    required: [],
-                },
-            },
-            {
-                name: 'session_resume',
-                description: 'Resume a previous Code Buddy session by ID.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        session_id: { type: 'string', description: 'The session ID to resume' },
-                    },
-                    required: ['session_id'],
-                },
-            },
-            {
-                name: 'web_search',
-                description: 'Search the web using Code Buddy\'s configured search providers.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        query: { type: 'string', description: 'The search query' },
-                        max_results: { type: 'number', description: 'Maximum results to return (default: 5)' },
-                        provider: { type: 'string', description: 'Search provider', enum: ['brave', 'perplexity', 'serper', 'duckduckgo', 'brave-mcp'] },
-                    },
-                    required: ['query'],
-                },
-            },
+        if (!this.allowWrite)
+            return;
+        const dynamicNames = new Set(this.registryCatalog.tools.map(({ definition }) => definition.name));
+        const shouldRegister = (name) => !dynamicNames.has(name) && shouldMatchPatterns(name, this.patterns);
+        const getAgent = () => this.ensureAgent();
+        registerAgentTools(this.mcpServer, getAgent, shouldRegister);
+        registerMemoryTools(this.mcpServer, shouldRegister);
+        registerCkgTools(this.mcpServer, shouldRegister);
+        registerSessionTools(this.mcpServer, getAgent, shouldRegister);
+        registerDesktopTools(this.mcpServer, shouldRegister);
+        const candidates = [
+            'agent_chat',
+            'agent_task',
+            'agent_plan',
+            'memory_search',
+            'memory_save',
+            'ckg_recall',
+            'ckg_ingest',
+            'session_list',
+            'session_resume',
+            'web_search',
+            'desktop_screenshot',
+            'desktop_snapshot',
+            ...(desktopControlEnabled()
+                ? ['desktop_click', 'desktop_type', 'desktop_move_mouse', 'desktop_key']
+                : []),
         ];
+        this.supplementalToolNames.push(...candidates.filter(shouldRegister));
     }
-    /**
-     * Lazily initialize tool instances on first use.
-     */
-    async ensureTools() {
-        if (this.textEditor)
-            return;
-        const [{ TextEditorTool }, { SearchTool }, { GitTool }, { BashTool },] = await Promise.all([
-            import('../tools/text-editor.js'),
-            import('../tools/search.js'),
-            import('../tools/git-tool.js'),
-            import('../tools/bash/index.js'),
-        ]);
-        // Enable auto-approve for MCP server mode (no interactive confirmation)
-        const { ConfirmationService } = await import('../utils/confirmation-service.js');
-        const confirmService = ConfirmationService.getInstance();
-        confirmService.setSessionFlag('allOperations', true);
-        this.textEditor = new TextEditorTool();
-        this.searchTool = new SearchTool();
-        this.gitTool = new GitTool();
-        this.bashTool = new BashTool();
-    }
-    /**
-     * Convert a ToolResult to MCP CallToolResult format.
-     */
     formatResult(result) {
         const text = result.success
-            ? (result.output || result.content || 'Done')
-            : (result.error || 'Unknown error');
+            ? result.output ?? result.content ?? stringifyResultData(result.data ?? 'Done')
+            : result.error ?? 'Unknown error';
         return {
             content: [{ type: 'text', text }],
-            isError: !result.success,
+            ...(result.success ? {} : { isError: true }),
         };
     }
-    /**
-     * Register all Code Buddy tools with the MCP server.
-     */
     registerTools() {
-        // read_file
-        this.mcpServer.tool('read_file', 'Read the contents of a file. Returns the file content with line numbers.', {
-            path: z.string().describe('Absolute or relative path to the file to read'),
-            start_line: z.number().optional().describe('Optional start line (1-indexed)'),
-            end_line: z.number().optional().describe('Optional end line (1-indexed)'),
-        }, async (args) => {
-            await this.ensureTools();
-            const viewRange = (args.start_line !== undefined && args.end_line !== undefined)
-                ? [args.start_line, args.end_line]
-                : undefined;
-            const result = await this.textEditor.view(args.path, viewRange);
-            return this.formatResult(result);
-        });
-        // write_file
-        this.mcpServer.tool('write_file', 'Write content to a file. Creates the file if it does not exist, or overwrites it.', {
-            path: z.string().describe('Absolute or relative path to the file to write'),
-            content: z.string().describe('The content to write to the file'),
-        }, async (args) => {
-            await this.ensureTools();
-            const result = await this.textEditor.create(args.path, args.content);
-            return this.formatResult(result);
-        });
-        // edit_file
-        this.mcpServer.tool('edit_file', 'Edit a file by replacing an exact string match with new content.', {
-            path: z.string().describe('Path to the file to edit'),
-            old_string: z.string().describe('The exact string to find and replace'),
-            new_string: z.string().describe('The replacement string'),
-        }, async (args) => {
-            await this.ensureTools();
-            const result = await this.textEditor.strReplace(args.path, args.old_string, args.new_string);
-            return this.formatResult(result);
-        });
-        // bash
-        this.mcpServer.tool('bash', 'Execute a shell command and return its output.', {
-            command: z.string().describe('The shell command to execute'),
-            timeout: z.number().optional().describe('Timeout in milliseconds (default: 30000)'),
-        }, async (args) => {
-            await this.ensureTools();
-            const result = await this.bashTool.execute(args.command, args.timeout ?? 30000);
-            return this.formatResult(result);
-        });
-        // search_files
-        this.mcpServer.tool('search_files', 'Search for text patterns in files using ripgrep.', {
-            query: z.string().describe('The search query (text or regex pattern)'),
-            path: z.string().optional().describe('Directory to search in (defaults to cwd)'),
-            include_pattern: z.string().optional().describe('Glob pattern for files to include (e.g., "*.ts")'),
-            case_sensitive: z.boolean().optional().describe('Whether the search is case-sensitive (default: false)'),
-            max_results: z.number().optional().describe('Maximum number of results to return (default: 50)'),
-        }, async (args) => {
-            await this.ensureTools();
-            const result = await this.searchTool.search(args.query, {
-                searchType: 'text',
-                includePattern: args.include_pattern,
-                caseSensitive: args.case_sensitive ?? false,
-                maxResults: args.max_results ?? 50,
-            });
-            return this.formatResult(result);
-        });
-        // list_files
-        this.mcpServer.tool('list_files', 'List files and directories at a given path.', {
-            path: z.string().optional().describe('Directory path to list (defaults to cwd)'),
-        }, async (args) => {
-            await this.ensureTools();
-            const targetPath = args.path || process.cwd();
-            const result = await this.textEditor.view(targetPath);
-            return this.formatResult(result);
-        });
-        // git
-        this.mcpServer.tool('git', 'Execute git operations: status, diff, log, add, commit, branch, checkout.', {
-            subcommand: z.enum(['status', 'diff', 'log', 'add', 'commit', 'branch', 'checkout'])
-                .describe('Git subcommand to run'),
-            args: z.object({
-                files: z.array(z.string()).optional().describe('Files for add/diff'),
-                message: z.string().optional().describe('Commit message'),
-                staged: z.boolean().optional().describe('Show staged changes (for diff)'),
-                count: z.number().optional().describe('Number of log entries'),
-                branch_name: z.string().optional().describe('Branch name for branch/checkout'),
-            }).optional().describe('Arguments for the git subcommand'),
-        }, async (args) => {
-            await this.ensureTools();
-            const git = this.gitTool;
-            const subArgs = args.args || {};
-            try {
-                switch (args.subcommand) {
-                    case 'status': {
-                        const status = await git.getStatus();
-                        const lines = [
-                            `Branch: ${status.branch}`,
-                            `Ahead: ${status.ahead}, Behind: ${status.behind}`,
-                        ];
-                        if (status.staged.length > 0)
-                            lines.push(`Staged:\n  ${status.staged.join('\n  ')}`);
-                        if (status.unstaged.length > 0)
-                            lines.push(`Unstaged:\n  ${status.unstaged.join('\n  ')}`);
-                        if (status.untracked.length > 0)
-                            lines.push(`Untracked:\n  ${status.untracked.join('\n  ')}`);
-                        return { content: [{ type: 'text', text: lines.join('\n') }] };
-                    }
-                    case 'diff': {
-                        const diff = await git.getDiff(subArgs.staged ?? false);
-                        return { content: [{ type: 'text', text: diff || 'No changes' }] };
-                    }
-                    case 'log': {
-                        const log = await git.getLog(subArgs.count ?? 10);
-                        return { content: [{ type: 'text', text: log || 'No commits' }] };
-                    }
-                    case 'add': {
-                        const files = subArgs.files;
-                        const result = await git.add(files && files.length > 0 ? files : 'all');
-                        return this.formatResult(result);
-                    }
-                    case 'commit': {
-                        if (!subArgs.message) {
-                            return { content: [{ type: 'text', text: 'Error: commit message is required' }], isError: true };
-                        }
-                        const result = await git.commit(subArgs.message);
-                        return this.formatResult(result);
-                    }
-                    case 'branch': {
-                        // List branches or create one
-                        const result = await git.branch(subArgs.branch_name);
-                        return this.formatResult(result);
-                    }
-                    case 'checkout': {
-                        if (!subArgs.branch_name) {
-                            return { content: [{ type: 'text', text: 'Error: branch_name is required for checkout' }], isError: true };
-                        }
-                        const result = await git.checkout(subArgs.branch_name);
-                        return this.formatResult(result);
+        for (const entry of this.registryCatalog.tools) {
+            const { definition, adapter, metadata } = entry;
+            this.mcpServer.registerTool(definition.name, {
+                description: definition.description,
+                inputSchema: jsonSchemaToZod(definition.inputSchema),
+                annotations: {
+                    readOnlyHint: definition.readOnly,
+                    destructiveHint: !definition.readOnly,
+                    idempotentHint: definition.readOnly,
+                    openWorldHint: metadata?.makesNetworkRequests === true,
+                },
+            }, async (rawArgs) => {
+                try {
+                    if (!definition.readOnly)
+                        await this.ensureWriteAccess();
+                    const args = rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
+                        ? rawArgs
+                        : {};
+                    const validation = adapter.validate?.(args);
+                    if (validation && !validation.valid) {
+                        return this.formatResult({
+                            success: false,
+                            error: `Validation failed: ${validation.errors?.join(', ') || 'invalid arguments'}`,
+                        });
                     }
-                    default:
-                        return { content: [{ type: 'text', text: `Unknown git subcommand: ${args.subcommand}` }], isError: true };
+                    const context = { cwd: this.workingDirectory };
+                    return this.formatResult(await adapter.execute(args, context));
                 }
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                return { content: [{ type: 'text', text: `Git error: ${message}` }], isError: true };
-            }
-        });
+                catch (error) {
+                    return this.formatResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            });
+        }
     }
-    /**
-     * Start the MCP server over stdio transport.
-     * This method blocks until the transport is closed.
-     */
     async start() {
-        if (this.running) {
+        if (this.running)
             throw new Error('MCP server is already running');
-        }
+        this.setupApprovalBridge();
         this.transport = new StdioServerTransport();
         await this.mcpServer.connect(this.transport);
         this.running = true;
     }
-    /**
-     * Stop the MCP server and close the transport.
-     */
     async stop() {
         if (!this.running)
             return;
-        // Dispose agent if initialized
+        ConfirmationService.getInstance().setMcpApprovalBridge(null);
         if (this.agent) {
             try {
                 this.agent.dispose();
             }
             catch {
-                // Ignore disposal errors
+                // Best-effort shutdown: the transport must still be closed.
             }
             this.agent = null;
             this.agentInitPromise = null;
@@ -546,9 +516,6 @@ export class CodeBuddyMCPServer {
         this.transport = null;
         this.running = false;
     }
-    /**
-     * Whether the server is currently running.
-     */
     isRunning() {
         return this.running;
     }