@majkapp/majk-chat-mcp 1.0.0

package/dist/plugin.d.ts

@@ -0,0 +1,24 @@
+import { ToolRegistry } from '@majkapp/majk-chat-core/dist/tools/tool.interface';
+import { MCPPluginOptions } from './types/config';
+import { ToolFilter } from './tools/tool-filter';
+import { MCPPermissionHandler } from './tools/permission-handler';
+export declare class MCPPlugin {
+    private options;
+    private mcpClient;
+    private toolFilter;
+    private permissionHandler;
+    private registry;
+    private registeredTools;
+    constructor(options?: MCPPluginOptions);
+    initialize(registry: ToolRegistry): Promise<void>;
+    private registerDynamicServer;
+    private connectServer;
+    private discoverAndRegisterTools;
+    shutdown(): Promise<void>;
+    getRegisteredTools(): string[];
+    getToolFilter(): ToolFilter;
+    getPermissionHandler(): MCPPermissionHandler;
+    addServer(serverName: string, serverConfig: any): Promise<void>;
+    removeServer(serverName: string): Promise<void>;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAgB,MAAM,mDAAmD,CAAC;AAG/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGlD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAElE,qBAAa,SAAS;IAOR,OAAO,CAAC,OAAO;IAN3B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,iBAAiB,CAAuB;IAChD,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,eAAe,CAAwC;gBAE3C,OAAO,GAAE,gBAAqB;IAa5C,UAAU,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;YAwBzC,qBAAqB;YA2CrB,aAAa;YAMb,wBAAwB;IAoEhC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAW/B,kBAAkB,IAAI,MAAM,EAAE;IAI9B,aAAa,IAAI,UAAU;IAI3B,oBAAoB,IAAI,oBAAoB;IAItC,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAK/D,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAatD"}

package/dist/plugin.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPPlugin = void 0;
+const mcp_client_1 = require("./client/mcp-client");
+const parser_1 = require("./config/parser");
+const mcp_tool_executor_1 = require("./tools/mcp-tool-executor");
+const dynamic_executor_1 = require("./tools/dynamic-executor");
+const tool_filter_1 = require("./tools/tool-filter");
+const permission_handler_1 = require("./tools/permission-handler");
+class MCPPlugin {
+    constructor(options = {}) {
+        this.options = options;
+        this.registry = null;
+        this.registeredTools = new Map();
+        this.mcpClient = new mcp_client_1.MCPClient(options.quiet || false);
+        this.toolFilter = new tool_filter_1.ToolFilter(options.allowedTools, options.disallowedTools);
+        this.permissionHandler = new permission_handler_1.MCPPermissionHandler(this.mcpClient, options.permissionPromptTool, options.quiet || false);
+    }
+    async initialize(registry) {
+        this.registry = registry;
+        const config = parser_1.MCPConfigParser.parseConfig(this.options);
+        for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+            try {
+                parser_1.MCPConfigParser.validateServerConfig(serverName, serverConfig);
+                if (parser_1.MCPConfigParser.isDynamicServer(serverConfig)) {
+                    // Handle dynamic server directly
+                    await this.registerDynamicServer(serverName, serverConfig);
+                }
+                else {
+                    // Handle traditional MCP server
+                    await this.connectServer(serverName, serverConfig);
+                }
+            }
+            catch (error) {
+                if (!this.options.quiet) {
+                    console.error(`Failed to setup MCP server "${serverName}":`, error);
+                }
+            }
+        }
+    }
+    async registerDynamicServer(serverName, config) {
+        for (const command of config.commands) {
+            const executor = new dynamic_executor_1.DynamicCommandExecutor(serverName, command);
+            if (this.toolFilter.isAllowed(executor.name)) {
+                if (this.options.permissionPromptTool) {
+                    const originalExecute = executor.execute.bind(executor);
+                    executor.execute = async (args, context) => {
+                        const permissionResult = await this.permissionHandler.requestPermissionWithUpdate(executor.name, args, context);
+                        if (!permissionResult.allowed) {
+                            return {
+                                success: false,
+                                error: `Permission denied for tool: ${executor.name}`
+                            };
+                        }
+                        // Use updated input if provided by permission handler
+                        const finalArgs = permissionResult.updatedInput !== undefined
+                            ? permissionResult.updatedInput
+                            : args;
+                        return originalExecute(finalArgs, context);
+                    };
+                }
+                this.registry?.register(executor);
+                this.registeredTools.set(executor.name, executor);
+                if (!this.options.quiet) {
+                    console.log(`Registered dynamic MCP tool: ${executor.name}`);
+                }
+            }
+            else {
+                if (!this.options.quiet) {
+                    console.log(`Filtered out dynamic MCP tool: ${executor.name}`);
+                }
+            }
+        }
+    }
+    async connectServer(serverName, serverConfig) {
+        const connection = await this.mcpClient.connect(serverName, serverConfig);
+        await this.discoverAndRegisterTools(connection.serverName);
+    }
+    async discoverAndRegisterTools(serverName) {
+        const connection = this.mcpClient.getConnection(serverName);
+        if (!connection) {
+            throw new Error(`No connection found for server: ${serverName}`);
+        }
+        try {
+            const toolsResponse = await connection.client.listTools();
+            if (!toolsResponse.tools || !Array.isArray(toolsResponse.tools)) {
+                if (!this.options.quiet) {
+                    console.warn(`No tools found for MCP server "${serverName}"`);
+                }
+                return;
+            }
+            for (const tool of toolsResponse.tools) {
+                const executor = new mcp_tool_executor_1.MCPToolExecutor(serverName, tool.name, tool, connection);
+                if (this.toolFilter.isAllowed(executor.name)) {
+                    if (this.options.permissionPromptTool) {
+                        const originalExecute = executor.execute.bind(executor);
+                        executor.execute = async (args, context) => {
+                            const permissionResult = await this.permissionHandler.requestPermissionWithUpdate(executor.name, args, context);
+                            if (!permissionResult.allowed) {
+                                return {
+                                    success: false,
+                                    error: `Permission denied for tool: ${executor.name}`
+                                };
+                            }
+                            // Use updated input if provided by permission handler
+                            const finalArgs = permissionResult.updatedInput !== undefined
+                                ? permissionResult.updatedInput
+                                : args;
+                            return originalExecute(finalArgs, context);
+                        };
+                    }
+                    this.registry?.register(executor);
+                    this.registeredTools.set(executor.name, executor);
+                    if (!this.options.quiet) {
+                        console.log(`Registered MCP tool: ${executor.name}`);
+                    }
+                }
+                else {
+                    if (!this.options.quiet) {
+                        console.log(`Filtered out MCP tool: ${executor.name}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (!this.options.quiet) {
+                console.error(`Failed to discover tools from server "${serverName}":`, error);
+            }
+        }
+    }
+    async shutdown() {
+        for (const toolName of this.registeredTools.keys()) {
+            if (!this.options.quiet) {
+                console.log(`Unregistering MCP tool: ${toolName}`);
+            }
+        }
+        this.registeredTools.clear();
+        await this.mcpClient.disconnectAll();
+    }
+    getRegisteredTools() {
+        return Array.from(this.registeredTools.keys());
+    }
+    getToolFilter() {
+        return this.toolFilter;
+    }
+    getPermissionHandler() {
+        return this.permissionHandler;
+    }
+    async addServer(serverName, serverConfig) {
+        parser_1.MCPConfigParser.validateServerConfig(serverName, serverConfig);
+        await this.connectServer(serverName, serverConfig);
+    }
+    async removeServer(serverName) {
+        const toolsToRemove = Array.from(this.registeredTools.entries())
+            .filter(([name]) => name.startsWith(`mcp__${serverName}__`));
+        for (const [toolName] of toolsToRemove) {
+            this.registeredTools.delete(toolName);
+            if (!this.options.quiet) {
+                console.log(`Unregistered MCP tool: ${toolName}`);
+            }
+        }
+        await this.mcpClient.disconnect(serverName);
+    }
+}
+exports.MCPPlugin = MCPPlugin;

package/dist/tools/dynamic-executor.d.ts

@@ -0,0 +1,32 @@
+import { ToolExecutor, ToolDefinition, ToolResult } from '@majkapp/majk-chat-core/dist/tools/tool.interface';
+import { RequestContext } from '@majkapp/majk-chat-core/dist/types/requests';
+import { DynamicCommand } from '../types/config';
+export declare class DynamicCommandExecutor implements ToolExecutor {
+    readonly name: string;
+    readonly definition: ToolDefinition;
+    private command;
+    constructor(serverName: string, command: DynamicCommand);
+    execute(args: any, context: RequestContext): Promise<ToolResult>;
+    validateArgs(args: any): boolean;
+    /**
+     * Resolve template variables in strings using {{variable}} syntax
+     * Supports conditionals: {{#if variable}}text{{/if}}
+     * Supports loops: {{#each array}}{{this}}{{/each}}
+     */
+    private resolveTemplate;
+    /**
+     * Resolve environment variables, supporting $VAR syntax
+     */
+    private resolveEnv;
+    /**
+     * Resolve file paths, expanding ~ to home directory
+     */
+    private resolvePath;
+    /**
+     * Execute command and return result
+     */
+    private executeCommand;
+    private inferSideEffects;
+    private shouldRequireConfirmation;
+}
+//# sourceMappingURL=dynamic-executor.d.ts.map

package/dist/tools/dynamic-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-executor.d.ts","sourceRoot":"","sources":["../../src/tools/dynamic-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mDAAmD,CAAC;AAC7G,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAKjD,qBAAa,sBAAuB,YAAW,YAAY;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,OAAO,CAAC,OAAO,CAAiB;gBAEpB,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc;IAiBjD,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IAmEtE,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAYhC;;;;OAIG;IACH,OAAO,CAAC,eAAe;IA2CvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAoBlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAOnB;;OAEG;IACH,OAAO,CAAC,cAAc;IA4CtB,OAAO,CAAC,gBAAgB;IA6BxB,OAAO,CAAC,yBAAyB;CAIlC"}

package/dist/tools/dynamic-executor.js

@@ -0,0 +1,257 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicCommandExecutor = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class DynamicCommandExecutor {
+    constructor(serverName, command) {
+        this.name = `mcp__${serverName}__${command.name}`;
+        this.command = command;
+        this.definition = {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: command.description,
+                parameters: command.parameters
+            },
+            serverInvocable: true,
+            sideEffects: this.inferSideEffects(command),
+            requiresConfirmation: this.shouldRequireConfirmation(command)
+        };
+    }
+    async execute(args, context) {
+        try {
+            // Resolve template variables in command path and args
+            const resolvedPath = this.resolveTemplate(this.command.exec.path, args);
+            const resolvedArgs = this.command.exec.args.map(arg => this.resolveTemplate(arg, args)).filter(arg => arg.length > 0); // Remove empty args from conditionals
+            // Prepare environment
+            const env = {
+                ...process.env,
+                ...this.resolveEnv(this.command.exec.env || {}, args)
+            };
+            // Resolve working directory
+            const cwd = this.command.exec.cwd
+                ? this.resolvePath(this.command.exec.cwd)
+                : process.cwd();
+            const timeout = this.command.exec.timeoutMs || 30000;
+            const expectFormat = this.command.exec.expect || 'text';
+            // Execute command
+            const result = await this.executeCommand(resolvedPath, resolvedArgs, { env, cwd, timeout });
+            // Parse result based on expected format
+            let output;
+            if (expectFormat === 'json') {
+                try {
+                    output = JSON.parse(result.stdout);
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        error: `Failed to parse JSON output: ${e}. Raw output: ${result.stdout}`
+                    };
+                }
+            }
+            else {
+                output = result.stdout;
+            }
+            // Check for errors
+            if (result.code !== 0) {
+                return {
+                    success: false,
+                    error: `Command failed with exit code ${result.code}: ${result.stderr}`
+                };
+            }
+            return {
+                success: true,
+                output,
+                metadata: {
+                    command: resolvedPath,
+                    args: resolvedArgs,
+                    exitCode: result.code,
+                    stderr: result.stderr
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    validateArgs(args) {
+        const schema = this.command.parameters;
+        if (schema.required) {
+            for (const requiredField of schema.required) {
+                if (!(requiredField in args)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Resolve template variables in strings using {{variable}} syntax
+     * Supports conditionals: {{#if variable}}text{{/if}}
+     * Supports loops: {{#each array}}{{this}}{{/each}}
+     */
+    resolveTemplate(template, args) {
+        let result = template;
+        let prevResult = '';
+        // Process templates recursively until no more changes occur (handles nested templates)
+        while (result !== prevResult) {
+            prevResult = result;
+            // Handle conditionals: {{#if variable}}text{{/if}}
+            result = result.replace(/\{\{#if\s+(\w+)\}\}(.*?)\{\{\/if\}\}/g, (match, variable, content) => {
+                return args[variable] ? content : '';
+            });
+            // Handle each loops: {{#each array}}{{this}}{{/each}}
+            result = result.replace(/\{\{#each\s+(\w+)\}\}(.*?)\{\{\/each\}\}/g, (match, variable, content) => {
+                const array = args[variable];
+                if (Array.isArray(array)) {
+                    return array.map(item => content.replace(/\{\{this\}\}/g, String(item))).join(' ');
+                }
+                return '';
+            });
+            // Handle simple variables: {{variable}} (including nested properties like config.debug)
+            result = result.replace(/\{\{([\w.]+)\}\}/g, (match, variable) => {
+                // Handle nested properties
+                if (variable.includes('.')) {
+                    return ''; // Don't resolve nested properties as per test expectation
+                }
+                return args[variable] !== undefined ? String(args[variable]) : '';
+            });
+            // Handle environment variables: $VAR
+            result = result.replace(/\$(\w+)/g, (match, variable) => {
+                return process.env[variable] || '';
+            });
+        }
+        // Clean up multiple consecutive spaces but preserve other characters
+        result = result.replace(/ {2,}/g, ' ');
+        return result;
+    }
+    /**
+     * Resolve environment variables, supporting $VAR syntax
+     */
+    resolveEnv(envConfig, args) {
+        const resolved = {};
+        for (const [key, value] of Object.entries(envConfig)) {
+            let resolvedValue = value;
+            // Replace $VAR with process.env.VAR
+            resolvedValue = resolvedValue.replace(/\$(\w+)/g, (match, varName) => {
+                return process.env[varName] || '';
+            });
+            // Replace template variables
+            resolvedValue = this.resolveTemplate(resolvedValue, args);
+            resolved[key] = resolvedValue;
+        }
+        return resolved;
+    }
+    /**
+     * Resolve file paths, expanding ~ to home directory
+     */
+    resolvePath(inputPath) {
+        if (inputPath.startsWith('~')) {
+            return path.join(os.homedir(), inputPath.slice(1));
+        }
+        return path.resolve(inputPath);
+    }
+    /**
+     * Execute command and return result
+     */
+    executeCommand(command, args, options) {
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(command, args, {
+                env: options.env,
+                cwd: options.cwd,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            const timeout = setTimeout(() => {
+                child.kill('SIGKILL');
+                reject(new Error(`Command timed out after ${options.timeout}ms`));
+            }, options.timeout);
+            child.on('close', (code) => {
+                clearTimeout(timeout);
+                resolve({
+                    code: code || 0,
+                    stdout: stdout.trim(),
+                    stderr: stderr.trim()
+                });
+            });
+            child.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    inferSideEffects(command) {
+        const name = command.name.toLowerCase();
+        const description = command.description.toLowerCase();
+        const path = command.exec.path.toLowerCase();
+        // Check for external operations first (network calls, APIs)
+        if (path.includes('curl') || path.includes('wget') || path.includes('http') ||
+            name.includes('api') || description.includes('api') || description.includes('http') ||
+            description.includes('network') || description.includes('download')) {
+            return 'external';
+        }
+        if (name.includes('write') || name.includes('create') ||
+            name.includes('update') || name.includes('delete') ||
+            description.includes('write') || description.includes('create') ||
+            description.includes('update') || description.includes('delete')) {
+            return 'write';
+        }
+        if (name.includes('read') || name.includes('get') ||
+            name.includes('list') || name.includes('fetch') ||
+            description.includes('read') || description.includes('get') ||
+            description.includes('list') || description.includes('fetch')) {
+            return 'read';
+        }
+        return 'external'; // Dynamic commands are typically external
+    }
+    shouldRequireConfirmation(command) {
+        const sideEffects = this.inferSideEffects(command);
+        return sideEffects === 'write' || sideEffects === 'external';
+    }
+}
+exports.DynamicCommandExecutor = DynamicCommandExecutor;

package/dist/tools/mcp-tool-executor.d.ts

@@ -0,0 +1,16 @@
+import { ToolExecutor, ToolDefinition, ToolResult } from '@majkapp/majk-chat-core/dist/tools/tool.interface';
+import { RequestContext } from '@majkapp/majk-chat-core/dist/types/requests';
+import { MCPConnection } from '../client/mcp-client';
+export declare class MCPToolExecutor implements ToolExecutor {
+    readonly name: string;
+    readonly definition: ToolDefinition;
+    private connection;
+    private originalToolName;
+    private inputSchema;
+    constructor(serverName: string, toolName: string, definition: any, connection: MCPConnection);
+    execute(args: any, context: RequestContext): Promise<ToolResult>;
+    validateArgs(args: any): boolean;
+    private inferSideEffects;
+    private shouldRequireConfirmation;
+}
+//# sourceMappingURL=mcp-tool-executor.d.ts.map

package/dist/tools/mcp-tool-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tool-executor.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-tool-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mDAAmD,CAAC;AAC7G,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGrD,qBAAa,eAAgB,YAAW,YAAY;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,WAAW,CAAM;gBAGvB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,GAAG,EACf,UAAU,EAAE,aAAa;IAoBrB,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IA8BtE,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAiBhC,OAAO,CAAC,gBAAgB;IA4BxB,OAAO,CAAC,yBAAyB;CAIlC"}

package/dist/tools/mcp-tool-executor.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPToolExecutor = void 0;
+const parser_1 = require("../config/parser");
+class MCPToolExecutor {
+    constructor(serverName, toolName, definition, connection) {
+        this.originalToolName = toolName;
+        this.name = parser_1.MCPConfigParser.formatToolName(serverName, toolName);
+        this.connection = connection;
+        this.inputSchema = definition.inputSchema || definition.parameters || {};
+        this.definition = {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: definition.description || '',
+                parameters: this.inputSchema
+            },
+            serverInvocable: true,
+            sideEffects: this.inferSideEffects(definition),
+            requiresConfirmation: this.shouldRequireConfirmation(definition)
+        };
+    }
+    async execute(args, context) {
+        try {
+            const result = await this.connection.client.callTool({
+                name: this.originalToolName,
+                arguments: args
+            });
+            if (result.isError) {
+                return {
+                    success: false,
+                    error: result.text || 'Tool execution failed'
+                };
+            }
+            return {
+                success: true,
+                output: result.content,
+                metadata: {
+                    serverName: this.connection.serverName,
+                    originalToolName: this.originalToolName
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    validateArgs(args) {
+        const schema = this.inputSchema;
+        if (!schema || typeof schema !== 'object') {
+            return true;
+        }
+        if (schema.type === 'object' && schema.required) {
+            for (const requiredField of schema.required) {
+                if (!(requiredField in args)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    inferSideEffects(definition) {
+        const name = definition.name?.toLowerCase() || '';
+        const description = definition.description?.toLowerCase() || '';
+        if (name.includes('write') || name.includes('create') ||
+            name.includes('update') || name.includes('delete') ||
+            description.includes('write') || description.includes('create') ||
+            description.includes('update') || description.includes('delete')) {
+            return 'write';
+        }
+        if (name.includes('read') || name.includes('get') ||
+            name.includes('list') || name.includes('fetch') ||
+            description.includes('read') || description.includes('get') ||
+            description.includes('list') || description.includes('fetch')) {
+            return 'read';
+        }
+        if (name.includes('http') || name.includes('api') ||
+            name.includes('request') || name.includes('call') ||
+            description.includes('http') || description.includes('api') ||
+            description.includes('request') || description.includes('external')) {
+            return 'external';
+        }
+        return 'none';
+    }
+    shouldRequireConfirmation(definition) {
+        const sideEffects = this.inferSideEffects(definition);
+        return sideEffects === 'write' || sideEffects === 'external';
+    }
+}
+exports.MCPToolExecutor = MCPToolExecutor;

package/dist/tools/permission-handler.d.ts

@@ -0,0 +1,18 @@
+import { PermissionHandler } from '@majkapp/majk-chat-core/dist/tools/tool.interface';
+import { RequestContext } from '@majkapp/majk-chat-core/dist/types/requests';
+import { MCPClient } from '../client/mcp-client';
+export interface PermissionResult {
+    allowed: boolean;
+    updatedInput?: any;
+}
+export declare class MCPPermissionHandler implements PermissionHandler {
+    private quiet;
+    private mcpClient;
+    private permissionTool;
+    constructor(mcpClient: MCPClient, permissionToolName?: string, quiet?: boolean);
+    requestPermission(toolName: string, args: any, context: RequestContext): Promise<boolean>;
+    requestPermissionWithUpdate(toolName: string, args: any, context: RequestContext): Promise<PermissionResult>;
+    setPermissionTool(toolName: string): void;
+    getPermissionTool(): string | null;
+}
+//# sourceMappingURL=permission-handler.d.ts.map

package/dist/tools/permission-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-handler.d.ts","sourceRoot":"","sources":["../../src/tools/permission-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mDAAmD,CAAC;AACtF,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAC7E,OAAO,EAAE,SAAS,EAAiB,MAAM,sBAAsB,CAAC;AAIhE,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB;AAED,qBAAa,oBAAqB,YAAW,iBAAiB;IAIG,OAAO,CAAC,KAAK;IAH5E,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,cAAc,CAAqC;gBAE/C,SAAS,EAAE,SAAS,EAAE,kBAAkB,CAAC,EAAE,MAAM,EAAU,KAAK,GAAE,OAAe;IAWvF,iBAAiB,CACrB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,GAAG,EACT,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,OAAO,CAAC;IAKb,2BAA2B,CAC/B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,GAAG,EACT,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,gBAAgB,CAAC;IAmE5B,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAOzC,iBAAiB,IAAI,MAAM,GAAG,IAAI;CAGnC"}