@majkapp/majk-chat-mcp 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+"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 });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const program = new commander_1.Command();
+program
+    .name('majk-mcp-server')
+    .description('Standalone MCP server for dynamic command execution')
+    .version('1.0.0');
+program
+    .command('serve')
+    .description('Start MCP server in stdio mode')
+    .option('-c, --config <file>', 'Configuration file path')
+    .option('--config-json <json>', 'Configuration as JSON string')
+    .action(async (options) => {
+    try {
+        let config;
+        if (options.config) {
+            const configData = await fs.promises.readFile(options.config, 'utf-8');
+            config = JSON.parse(configData);
+        }
+        else if (options.configJson) {
+            config = JSON.parse(options.configJson);
+        }
+        else {
+            console.error('Error: Must provide either --config or --config-json');
+            process.exit(1);
+        }
+        await startMCPServer(config);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command('validate')
+    .description('Validate configuration file')
+    .option('-c, --config <file>', 'Configuration file path')
+    .option('--config-json <json>', 'Configuration as JSON string')
+    .action(async (options) => {
+    try {
+        let config;
+        if (options.config) {
+            const configData = await fs.promises.readFile(options.config, 'utf-8');
+            config = JSON.parse(configData);
+        }
+        else if (options.configJson) {
+            config = JSON.parse(options.configJson);
+        }
+        else {
+            console.error('Error: Must provide either --config or --config-json');
+            process.exit(1);
+        }
+        validateConfig(config);
+        console.log('✅ Configuration is valid');
+        // List discovered tools
+        console.log('\nDiscovered tools:');
+        for (const cmd of config.commands) {
+            console.log(`  - ${cmd.name}: ${cmd.description}`);
+        }
+    }
+    catch (error) {
+        console.error('❌ Configuration error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+async function startMCPServer(config) {
+    validateConfig(config);
+    const server = new index_js_1.Server({
+        name: 'majk-dynamic-mcp-server',
+        version: '1.0.0'
+    }, {
+        capabilities: {
+            tools: {}
+        }
+    });
+    // Handle tools/list requests
+    server.setRequestHandler('tools/list', async () => {
+        return {
+            tools: config.commands.map(cmd => ({
+                name: cmd.name,
+                description: cmd.description,
+                inputSchema: cmd.parameters
+            }))
+        };
+    });
+    // Handle tools/call requests  
+    server.setRequestHandler('tools/call', async (request) => {
+        const toolName = request.params?.name;
+        const toolArgs = request.params?.arguments || {};
+        const command = config.commands.find(cmd => cmd.name === toolName);
+        if (!command) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        return await executeCommand(command, toolArgs);
+    });
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error(`MCP server started with ${config.commands.length} tools`);
+}
+async function executeCommand(command, args) {
+    // Resolve template variables
+    const resolvedPath = resolveTemplate(command.exec.path, args);
+    const resolvedArgs = command.exec.args
+        .map(arg => resolveTemplate(arg, args))
+        .filter(arg => arg.length > 0);
+    // Prepare environment
+    const env = {
+        ...process.env,
+        ...resolveEnv(command.exec.env || {}, args)
+    };
+    // Resolve working directory
+    const cwd = command.exec.cwd
+        ? resolvePath(command.exec.cwd)
+        : process.cwd();
+    const timeout = command.exec.timeoutMs || 30000;
+    const expectFormat = command.exec.expect || 'text';
+    try {
+        const result = await executeShellCommand(resolvedPath, resolvedArgs, { env, cwd, timeout });
+        if (result.code !== 0) {
+            throw new Error(`Command failed with exit code ${result.code}: ${result.stderr}`);
+        }
+        let output;
+        if (expectFormat === 'json') {
+            try {
+                output = JSON.parse(result.stdout);
+            }
+            catch (e) {
+                throw new Error(`Failed to parse JSON output: ${e}. Raw output: ${result.stdout}`);
+            }
+        }
+        else {
+            output = result.stdout;
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: typeof output === 'string' ? output : JSON.stringify(output, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        throw new Error(error instanceof Error ? error.message : String(error));
+    }
+}
+function resolveTemplate(template, args) {
+    let result = template;
+    // 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}}
+    result = result.replace(/\{\{(\w+)\}\}/g, (match, variable) => {
+        return args[variable] !== undefined ? String(args[variable]) : '';
+    });
+    return result;
+}
+function 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 = resolveTemplate(resolvedValue, args);
+        resolved[key] = resolvedValue;
+    }
+    return resolved;
+}
+function resolvePath(inputPath) {
+    if (inputPath.startsWith('~')) {
+        return path.join(os.homedir(), inputPath.slice(1));
+    }
+    return path.resolve(inputPath);
+}
+function executeShellCommand(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);
+        });
+    });
+}
+function validateConfig(config) {
+    if (!Array.isArray(config.commands)) {
+        throw new Error('Config must have a "commands" array');
+    }
+    for (const cmd of config.commands) {
+        if (!cmd.name || typeof cmd.name !== 'string') {
+            throw new Error('Command missing required field: name');
+        }
+        if (!cmd.description || typeof cmd.description !== 'string') {
+            throw new Error(`Command "${cmd.name}" missing required field: description`);
+        }
+        if (!cmd.parameters || typeof cmd.parameters !== 'object') {
+            throw new Error(`Command "${cmd.name}" missing required field: parameters`);
+        }
+        if (!cmd.exec || typeof cmd.exec !== 'object') {
+            throw new Error(`Command "${cmd.name}" missing required field: exec`);
+        }
+        if (!cmd.exec.path || typeof cmd.exec.path !== 'string') {
+            throw new Error(`Command "${cmd.name}" exec missing required field: path`);
+        }
+        if (!Array.isArray(cmd.exec.args)) {
+            throw new Error(`Command "${cmd.name}" exec.args must be an array`);
+        }
+    }
+}
+// Parse and execute
+if (require.main === module) {
+    program.parse(process.argv);
+}

package/dist/client/mcp-client.d.ts

@@ -0,0 +1,22 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { MCPServerConfig } from '../types/config';
+import { ChildProcess } from 'child_process';
+export interface MCPConnection {
+    client: Client;
+    transport: StdioClientTransport;
+    process: ChildProcess;
+    serverName: string;
+}
+export declare class MCPClient {
+    private quiet;
+    private connections;
+    constructor(quiet?: boolean);
+    connect(serverName: string, config: MCPServerConfig): Promise<MCPConnection>;
+    disconnect(serverName: string): Promise<void>;
+    disconnectAll(): Promise<void>;
+    getConnection(serverName: string): MCPConnection | undefined;
+    getAllConnections(): MCPConnection[];
+    private resolveArgs;
+}
+//# sourceMappingURL=mcp-client.d.ts.map

package/dist/client/mcp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.d.ts","sourceRoot":"","sources":["../../src/client/mcp-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAS,YAAY,EAAE,MAAM,eAAe,CAAC;AAIpD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,oBAAoB,CAAC;IAChC,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,SAAS;IAGR,OAAO,CAAC,KAAK;IAFzB,OAAO,CAAC,WAAW,CAAyC;gBAExC,KAAK,GAAE,OAAe;IAEpC,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAiE5E,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB7C,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAOpC,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI5D,iBAAiB,IAAI,aAAa,EAAE;IAIpC,OAAO,CAAC,WAAW;CAQpB"}

package/dist/client/mcp-client.js

@@ -0,0 +1,136 @@
+"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.MCPClient = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class MCPClient {
+    constructor(quiet = false) {
+        this.quiet = quiet;
+        this.connections = new Map();
+    }
+    async connect(serverName, config) {
+        if (this.connections.has(serverName)) {
+            return this.connections.get(serverName);
+        }
+        const args = this.resolveArgs(config.args);
+        const processEnv = process.env;
+        const configEnv = config.env || {};
+        const env = {};
+        // Merge environment variables, filtering out undefined values
+        for (const [key, value] of Object.entries(processEnv)) {
+            if (value !== undefined) {
+                env[key] = value;
+            }
+        }
+        for (const [key, value] of Object.entries(configEnv)) {
+            if (value !== undefined) {
+                env[key] = value;
+            }
+        }
+        const childProcess = (0, child_process_1.spawn)(config.command, args, {
+            env,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        childProcess.on('error', (error) => {
+            if (!this.quiet) {
+                console.error(`MCP server "${serverName}" process error:`, error);
+            }
+        });
+        childProcess.stderr?.on('data', (data) => {
+            if (!this.quiet) {
+                console.error(`MCP server "${serverName}" stderr:`, data.toString());
+            }
+        });
+        const transport = new stdio_js_1.StdioClientTransport({
+            command: config.command,
+            args: args,
+            env: env
+        });
+        const client = new index_js_1.Client({
+            name: `majk-chat-mcp-${serverName}`,
+            version: '1.0.0'
+        }, {
+            capabilities: {}
+        });
+        await client.connect(transport);
+        const connection = {
+            client,
+            transport,
+            process: childProcess,
+            serverName
+        };
+        this.connections.set(serverName, connection);
+        return connection;
+    }
+    async disconnect(serverName) {
+        const connection = this.connections.get(serverName);
+        if (!connection) {
+            return;
+        }
+        try {
+            await connection.client.close();
+        }
+        catch (error) {
+            if (!this.quiet) {
+                console.error(`Error closing MCP client for "${serverName}":`, error);
+            }
+        }
+        connection.process.kill();
+        this.connections.delete(serverName);
+    }
+    async disconnectAll() {
+        const disconnectPromises = Array.from(this.connections.keys()).map(serverName => this.disconnect(serverName));
+        await Promise.all(disconnectPromises);
+    }
+    getConnection(serverName) {
+        return this.connections.get(serverName);
+    }
+    getAllConnections() {
+        return Array.from(this.connections.values());
+    }
+    resolveArgs(args) {
+        return args.map(arg => {
+            if (arg.startsWith('~')) {
+                return path.join(os.homedir(), arg.slice(1));
+            }
+            return arg;
+        });
+    }
+}
+exports.MCPClient = MCPClient;

package/dist/config/parser.d.ts

@@ -0,0 +1,14 @@
+import { MCPConfig, MCPServerConfig, MCPServerConfigType, DynamicServerConfig, MCPPluginOptions, ParsedPermissionTool } from '../types/config';
+export { ParsedPermissionTool };
+export declare class MCPConfigParser {
+    static parseConfig(options: MCPPluginOptions): MCPConfig;
+    static parsePermissionTool(toolName: string): ParsedPermissionTool | null;
+    static formatToolName(serverName: string, toolName: string): string;
+    private static resolvePath;
+    private static mergeConfigs;
+    static validateServerConfig(name: string, config: MCPServerConfigType): void;
+    static validateTraditionalServerConfig(name: string, config: MCPServerConfig): void;
+    static validateDynamicServerConfig(name: string, config: DynamicServerConfig): void;
+    static isDynamicServer(config: MCPServerConfigType): config is DynamicServerConfig;
+}
+//# sourceMappingURL=parser.d.ts.map

package/dist/config/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/config/parser.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,SAAS,EACT,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAEhC,qBAAa,eAAe;IAC1B,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS;IAwBxD,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI;IAezE,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAMnE,OAAO,CAAC,MAAM,CAAC,WAAW;IAO1B,OAAO,CAAC,MAAM,CAAC,YAAY;IAS3B,MAAM,CAAC,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,IAAI;IAU5E,MAAM,CAAC,+BAA+B,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI;IAYnF,MAAM,CAAC,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,IAAI;IA2BnF,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,IAAI,mBAAmB;CAGnF"}

package/dist/config/parser.js

@@ -0,0 +1,142 @@
+"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.MCPConfigParser = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class MCPConfigParser {
+    static parseConfig(options) {
+        let config = { mcpServers: {} };
+        if (options.configPath) {
+            const resolvedPath = this.resolvePath(options.configPath);
+            if (fs.existsSync(resolvedPath)) {
+                const fileContent = fs.readFileSync(resolvedPath, 'utf-8');
+                const parsedConfig = JSON.parse(fileContent);
+                config = this.mergeConfigs(config, parsedConfig);
+            }
+        }
+        if (options.configString) {
+            const parsedConfig = JSON.parse(options.configString);
+            config = this.mergeConfigs(config, parsedConfig);
+        }
+        if (options.servers) {
+            config.mcpServers = { ...config.mcpServers, ...options.servers };
+        }
+        return config;
+    }
+    static parsePermissionTool(toolName) {
+        // Match pattern: mcp__<server>__<tool>
+        // Server name can contain underscores, so we need to be careful
+        const match = toolName.match(/^mcp__(.+?)__(.+)$/);
+        if (!match) {
+            return null;
+        }
+        return {
+            serverName: match[1],
+            toolName: match[2].replace(/_/g, ' '),
+            originalName: toolName
+        };
+    }
+    static formatToolName(serverName, toolName) {
+        const sanitizedServer = serverName.replace(/[^a-zA-Z0-9]/g, '_');
+        const sanitizedTool = toolName.replace(/[^a-zA-Z0-9]/g, '_');
+        return `mcp__${sanitizedServer}__${sanitizedTool}`;
+    }
+    static resolvePath(inputPath) {
+        if (inputPath.startsWith('~')) {
+            return path.join(os.homedir(), inputPath.slice(1));
+        }
+        return path.resolve(inputPath);
+    }
+    static mergeConfigs(base, override) {
+        return {
+            mcpServers: {
+                ...base.mcpServers,
+                ...override.mcpServers
+            }
+        };
+    }
+    static validateServerConfig(name, config) {
+        if ('commands' in config) {
+            // Dynamic server config
+            this.validateDynamicServerConfig(name, config);
+        }
+        else {
+            // Traditional MCP server config
+            this.validateTraditionalServerConfig(name, config);
+        }
+    }
+    static validateTraditionalServerConfig(name, config) {
+        if (!config.command) {
+            throw new Error(`MCP server "${name}" missing required field: command`);
+        }
+        if (!Array.isArray(config.args)) {
+            throw new Error(`MCP server "${name}" args must be an array`);
+        }
+        if (config.env && typeof config.env !== 'object') {
+            throw new Error(`MCP server "${name}" env must be an object`);
+        }
+    }
+    static validateDynamicServerConfig(name, config) {
+        if (!Array.isArray(config.commands)) {
+            throw new Error(`Dynamic MCP server "${name}" commands must be an array`);
+        }
+        for (const cmd of config.commands) {
+            if (!cmd.name || typeof cmd.name !== 'string') {
+                throw new Error(`Dynamic MCP server "${name}" command missing required field: name`);
+            }
+            if (!cmd.description || typeof cmd.description !== 'string') {
+                throw new Error(`Dynamic MCP server "${name}" command "${cmd.name}" missing required field: description`);
+            }
+            if (!cmd.parameters || typeof cmd.parameters !== 'object') {
+                throw new Error(`Dynamic MCP server "${name}" command "${cmd.name}" missing required field: parameters`);
+            }
+            if (!cmd.exec || typeof cmd.exec !== 'object') {
+                throw new Error(`Dynamic MCP server "${name}" command "${cmd.name}" missing required field: exec`);
+            }
+            if (!cmd.exec.path || typeof cmd.exec.path !== 'string') {
+                throw new Error(`Dynamic MCP server "${name}" command "${cmd.name}" exec missing required field: path`);
+            }
+            if (!Array.isArray(cmd.exec.args)) {
+                throw new Error(`Dynamic MCP server "${name}" command "${cmd.name}" exec.args must be an array`);
+            }
+        }
+    }
+    static isDynamicServer(config) {
+        return 'commands' in config;
+    }
+}
+exports.MCPConfigParser = MCPConfigParser;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { MCPPlugin } from './plugin';
+export { MCPClient, MCPConnection } from './client/mcp-client';
+export { MCPConfigParser } from './config/parser';
+export { MCPToolExecutor } from './tools/mcp-tool-executor';
+export { DynamicCommandExecutor } from './tools/dynamic-executor';
+export { ToolFilter } from './tools/tool-filter';
+export { MCPPermissionHandler, PermissionResult } from './tools/permission-handler';
+export * from './types/config';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACpF,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,32 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPPermissionHandler = exports.ToolFilter = exports.DynamicCommandExecutor = exports.MCPToolExecutor = exports.MCPConfigParser = exports.MCPClient = exports.MCPPlugin = void 0;
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "MCPPlugin", { enumerable: true, get: function () { return plugin_1.MCPPlugin; } });
+var mcp_client_1 = require("./client/mcp-client");
+Object.defineProperty(exports, "MCPClient", { enumerable: true, get: function () { return mcp_client_1.MCPClient; } });
+var parser_1 = require("./config/parser");
+Object.defineProperty(exports, "MCPConfigParser", { enumerable: true, get: function () { return parser_1.MCPConfigParser; } });
+var mcp_tool_executor_1 = require("./tools/mcp-tool-executor");
+Object.defineProperty(exports, "MCPToolExecutor", { enumerable: true, get: function () { return mcp_tool_executor_1.MCPToolExecutor; } });
+var dynamic_executor_1 = require("./tools/dynamic-executor");
+Object.defineProperty(exports, "DynamicCommandExecutor", { enumerable: true, get: function () { return dynamic_executor_1.DynamicCommandExecutor; } });
+var tool_filter_1 = require("./tools/tool-filter");
+Object.defineProperty(exports, "ToolFilter", { enumerable: true, get: function () { return tool_filter_1.ToolFilter; } });
+var permission_handler_1 = require("./tools/permission-handler");
+Object.defineProperty(exports, "MCPPermissionHandler", { enumerable: true, get: function () { return permission_handler_1.MCPPermissionHandler; } });
+__exportStar(require("./types/config"), exports);