@indiccoder/mentis-cli 1.1.4 → 1.1.5

package/dist/mcp/McpManager.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpManager = void 0;
+const McpClient_1 = require("./McpClient");
+const McpConfig_1 = require("./McpConfig");
+const ora_1 = __importDefault(require("ora"));
+const chalk_1 = __importDefault(require("chalk"));
+class McpManager {
+    constructor() {
+        this.connections = new Map();
+        this.configManager = new McpConfig_1.McpConfigManager();
+    }
+    getConfig() {
+        return this.configManager;
+    }
+    async connectToServer(serverName) {
+        const config = this.configManager.getServer(serverName);
+        if (!config) {
+            console.error(chalk_1.default.red(`MCP server "${serverName}" not found in configuration`));
+            return null;
+        }
+        // Check if already connected
+        if (this.connections.has(serverName)) {
+            console.log(chalk_1.default.yellow(`Already connected to ${serverName}`));
+            return this.connections.get(serverName);
+        }
+        const spinner = (0, ora_1.default)(`Connecting to MCP server: ${serverName}...`).start();
+        try {
+            // Set environment variables if specified
+            if (config.env) {
+                for (const [key, value] of Object.entries(config.env)) {
+                    if (value) {
+                        process.env[key] = value;
+                    }
+                    else if (!process.env[key]) {
+                        spinner.warn(chalk_1.default.yellow(`Environment variable ${key} is required for ${serverName}`));
+                        console.log(chalk_1.default.dim(`Set it with: export ${key}=your_key`));
+                        console.log(chalk_1.default.dim(`Or add it to your MCP configuration`));
+                    }
+                }
+            }
+            const client = new McpClient_1.McpClient(config.command, config.args);
+            await client.initialize();
+            const tools = await client.listTools();
+            const connection = {
+                client,
+                config,
+                tools,
+                connectedAt: new Date()
+            };
+            this.connections.set(serverName, connection);
+            spinner.succeed(chalk_1.default.green(`Connected to ${client.serverName}!`));
+            if (tools.length > 0) {
+                console.log(chalk_1.default.green(`Added ${tools.length} tools:`));
+                tools.forEach(t => {
+                    const description = t.description.length > 60
+                        ? t.description.substring(0, 60) + '...'
+                        : t.description;
+                    console.log(chalk_1.default.dim(`  - ${chalk_1.default.cyan(t.name)}: ${description}`));
+                });
+            }
+            else {
+                console.log(chalk_1.default.yellow('No tools available from this server'));
+            }
+            return connection;
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red(`Failed to connect to ${serverName}: ${error.message}`));
+            return null;
+        }
+    }
+    async disconnectFromServer(serverName) {
+        const connection = this.connections.get(serverName);
+        if (!connection) {
+            console.log(chalk_1.default.yellow(`Not connected to ${serverName}`));
+            return false;
+        }
+        try {
+            connection.client.disconnect();
+            this.connections.delete(serverName);
+            console.log(chalk_1.default.green(`Disconnected from ${serverName}`));
+            return true;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Error disconnecting from ${serverName}: ${error.message}`));
+            return false;
+        }
+    }
+    disconnectAll() {
+        const serverNames = Array.from(this.connections.keys());
+        for (const name of serverNames) {
+            this.disconnectFromServer(name);
+        }
+    }
+    getConnections() {
+        return Array.from(this.connections.values());
+    }
+    getConnection(name) {
+        return this.connections.get(name);
+    }
+    getAllTools() {
+        const allTools = [];
+        for (const connection of this.connections.values()) {
+            allTools.push(...connection.tools);
+        }
+        return allTools;
+    }
+    getServerNames() {
+        return Array.from(this.connections.keys());
+    }
+    getAvailableServers() {
+        return this.configManager.getConfig().servers;
+    }
+    async autoConnect() {
+        const autoConnectServers = this.configManager.getAutoConnectServers();
+        if (autoConnectServers.length === 0) {
+            return;
+        }
+        console.log(chalk_1.default.blue(`\nAuto-connecting to ${autoConnectServers.length} MCP servers...`));
+        for (const config of autoConnectServers) {
+            await this.connectToServer(config.name);
+        }
+    }
+    async listServers() {
+        const availableServers = this.configManager.getConfig().servers;
+        const connectedServers = this.getServerNames();
+        if (availableServers.length === 0) {
+            console.log(chalk_1.default.yellow('No MCP servers configured.'));
+            return;
+        }
+        console.log(chalk_1.default.cyan('\nMCP Servers:\n'));
+        for (const server of availableServers) {
+            const isConnected = connectedServers.includes(server.name);
+            const status = isConnected ? chalk_1.default.green('● Connected') : chalk_1.default.gray('○ Disconnected');
+            const auto = server.autoConnect ? chalk_1.default.dim('[auto]') : '';
+            console.log(`${status} ${chalk_1.default.bold(server.name)} ${auto}`);
+            if (server.description) {
+                console.log(chalk_1.default.dim(`  ${server.description}`));
+            }
+            if (isConnected) {
+                const connection = this.getConnection(server.name);
+                if (connection && connection.tools.length > 0) {
+                    console.log(chalk_1.default.dim(`  Tools: ${connection.tools.map(t => t.name).join(', ')}`));
+                }
+            }
+            console.log('');
+        }
+    }
+    async addServer(name, command, args, description) {
+        const serverConfig = {
+            name,
+            command,
+            args,
+            description,
+            autoConnect: false
+        };
+        this.configManager.addServer(serverConfig);
+        console.log(chalk_1.default.green(`Added MCP server "${name}" to configuration`));
+    }
+    async removeServer(name) {
+        // Disconnect if connected
+        if (this.connections.has(name)) {
+            await this.disconnectFromServer(name);
+        }
+        this.configManager.removeServer(name);
+        console.log(chalk_1.default.green(`Removed MCP server "${name}" from configuration`));
+    }
+    async testConnection(serverName) {
+        const connection = this.getConnection(serverName);
+        if (!connection) {
+            console.log(chalk_1.default.red(`Not connected to ${serverName}`));
+            return false;
+        }
+        try {
+            // Try to list tools as a test
+            await connection.client.listTools();
+            console.log(chalk_1.default.green(`${serverName} connection is healthy`));
+            return true;
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`${serverName} connection test failed: ${error.message}`));
+            return false;
+        }
+    }
+}
+exports.McpManager = McpManager;

package/dist/repl/PersistentShell.js

@@ -13,6 +13,7 @@ class PersistentShell {
         this.delimiter = 'MENTIS_SHELL_DELIMITER';
         this.resolveCallback = null;
         this.rejectCallback = null;
+        this.COMMAND_TIMEOUT = 120000; // 2 minutes timeout for shell commands
         // Lazy init: Do not spawn here.
     }
     initialize() {
@@ -60,7 +61,25 @@ class PersistentShell {
             this.resolveCallback = resolve;
             this.rejectCallback = reject;
             this.buffer = '';
-            const cleanCommand = command.replace(/\n/g, '; ');
+            // Set timeout to prevent indefinite hangs
+            const timeout = setTimeout(() => {
+                this.resolveCallback = null;
+                this.rejectCallback = null;
+                reject(new Error(`Shell command timeout after ${this.COMMAND_TIMEOUT}ms`));
+            }, this.COMMAND_TIMEOUT);
+            // Store timeout for cleanup
+            const originalResolve = resolve;
+            const wrappedResolve = (output) => {
+                clearTimeout(timeout);
+                originalResolve(output);
+            };
+            this.resolveCallback = wrappedResolve;
+            let cleanCommand = command.replace(/\n/g, '; ');
+            // Fix: PowerShell alias 'curl' -> 'Invoke-WebRequest' causes issues for linux-style curl commands.
+            // Force usage of 'curl.exe' if on Windows.
+            if (os_1.default.platform() === 'win32') {
+                cleanCommand = cleanCommand.replace(/(^|[\s|;&])curl(\s|$)/g, '$1curl.exe$2');
+            }
             const fullCommand = `${cleanCommand}; echo "${this.delimiter}"\n`;
             this.process?.stdin.write(fullCommand);
         });