@indiccoder/mentis-cli 1.1.4 → 1.1.5

package/src/debug_lite.ts

@@ -0,0 +1,18 @@
+
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+const query = "expo go latest sdk";
+const url = `https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`;
+console.log(`Fetching Lite DDG: ${url}`);
+
+try {
+    const cmd = `curl -s -L -A "Mozilla/5.0" "${url}"`;
+    const html = execSync(cmd, { encoding: 'utf-8' });
+
+    fs.writeFileSync('lite_dump.html', html);
+    console.log('Dumped HTML to lite_dump.html');
+
+} catch (e: any) {
+    console.error('Error:', e.message);
+}

package/src/debug_lite_headers.ts

@@ -0,0 +1,25 @@
+
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+const query = "expo go latest sdk";
+const url = `https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`;
+console.log(`Testing Lite Headers: ${url}`);
+
+try {
+    const cmd = `curl -s -L -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36" -H "Referer: https://duckduckgo.com/" -H "Accept-Language: en-US,en;q=0.9" "${url}"`;
+    const html = execSync(cmd, { encoding: 'utf-8' });
+
+    fs.writeFileSync('lite_headers_dump.html', html);
+
+    if (html.includes('anomaly-modal')) {
+        console.log('STILL BLOCKED by Captcha');
+    } else if (html.includes('result-link')) {
+        console.log('SUCCESS! Found result links.');
+    } else {
+        console.log('Unknown response. Check dump.');
+    }
+
+} catch (e: any) {
+    console.error('Error:', e.message);
+}

package/src/debug_search.ts

@@ -0,0 +1,18 @@
+
+import { execSync } from 'child_process';
+
+const query = "test";
+const url = `https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`;
+console.log(`Testing Lite DDG: ${url}`);
+
+try {
+    const cmd = `curl -s -L -A "Mozilla/5.0" "${url}"`;
+    const html = execSync(cmd, { encoding: 'utf-8' });
+
+    console.log('HTML Length:', html.length);
+    console.log('Snippet (first 2000 chars):');
+    console.log(html.substring(0, 2000));
+
+} catch (e: any) {
+    console.error('Error:', e.message);
+}

package/src/index.ts

@@ -116,6 +116,18 @@ async function main(): Promise<void> {
     await repl.start();
 }
 
+// Global error handlers to prevent silent crashes
+process.on('uncaughtException', (error) => {
+    console.error('Uncaught Exception:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    process.exit(1);
+});
+
 // Start the application
 main().catch((error) => {
     console.error('Fatal error:', error);

package/src/mcp/JsonRpcClient.ts

@@ -23,6 +23,7 @@ export class JsonRpcClient {
     private process: ChildProcess;
     private sequence = 0;
     private pendingRequests = new Map<number | string, { resolve: Function; reject: Function }>();
+    private readonly REQUEST_TIMEOUT = 30000; // 30 seconds timeout
 
     constructor(command: string, args: string[]) {
         this.process = spawn(command, args, {
@@ -50,6 +51,10 @@ export class JsonRpcClient {
                 const handler = this.pendingRequests.get(message.id);
                 if (handler) {
                     this.pendingRequests.delete(message.id);
+                    // Clear timeout if present
+                    if ((handler as any).timeout) {
+                        clearTimeout((handler as any).timeout);
+                    }
                     if (message.error) {
                         handler.reject(new Error(message.error.message));
                     } else {
@@ -76,12 +81,26 @@ export class JsonRpcClient {
 
         return new Promise((resolve, reject) => {
             this.pendingRequests.set(id, { resolve, reject });
+
+            // Set timeout to prevent indefinite hangs
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`MCP request timeout after ${this.REQUEST_TIMEOUT}ms`));
+            }, this.REQUEST_TIMEOUT);
+
+            // Store timeout with the request for cleanup
+            const handler = this.pendingRequests.get(id);
+            if (handler) {
+                (handler as any).timeout = timeout;
+            }
+
             try {
                 if (!this.process.stdin) throw new Error('Stdin not available');
                 const data = JSON.stringify(request) + '\n';
                 this.process.stdin.write(data);
             } catch (e) {
                 this.pendingRequests.delete(id);
+                clearTimeout(timeout);
                 reject(e);
             }
         });

package/src/mcp/McpConfig.ts

@@ -0,0 +1,153 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+export interface McpServerConfig {
+    name: string;
+    command: string;
+    args: string[];
+    description?: string;
+    autoConnect?: boolean;
+    env?: Record<string, string>;
+}
+
+export interface McpConfig {
+    servers: McpServerConfig[];
+}
+
+export class McpConfigManager {
+    private configPath: string;
+    private config: McpConfig;
+
+    constructor() {
+        // Config path: ~/.mentis/mcp.json
+        this.configPath = join(homedir(), '.mentis', 'mcp.json');
+        this.config = this.loadConfig();
+    }
+
+    private loadConfig(): McpConfig {
+        if (existsSync(this.configPath)) {
+            try {
+                const content = readFileSync(this.configPath, 'utf-8');
+                return JSON.parse(content);
+            } catch (error) {
+                console.warn('Failed to load MCP config, using defaults:', error);
+            }
+        }
+
+        // Default configuration with popular MCP servers
+        return this.getDefaultConfig();
+    }
+
+    private getDefaultConfig(): McpConfig {
+        return {
+            servers: [
+                {
+                    name: 'Exa Search',
+                    command: 'npx',
+                    args: ['-y', '@exa-labs/mcp-server-exa'],
+                    description: 'Web search via Exa API (requires EXA_API_KEY)',
+                    autoConnect: false,
+                    env: {
+                        EXA_API_KEY: process.env.EXA_API_KEY || ''
+                    }
+                },
+                {
+                    name: 'Memory',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-memory'],
+                    description: 'Persistent memory storage for conversations',
+                    autoConnect: false
+                },
+                {
+                    name: 'Filesystem',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-filesystem', process.cwd()],
+                    description: 'Enhanced filesystem operations',
+                    autoConnect: false
+                },
+                {
+                    name: 'GitHub',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-github'],
+                    description: 'GitHub repository management and operations',
+                    autoConnect: false,
+                    env: {
+                        GITHUB_PERSONAL_ACCESS_TOKEN: process.env.GITHUB_PERSONAL_ACCESS_TOKEN || ''
+                    }
+                },
+                {
+                    name: 'Puppeteer',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-puppeteer'],
+                    description: 'Web browser automation and scraping',
+                    autoConnect: false
+                },
+                {
+                    name: 'Brave Search',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-brave-search'],
+                    description: 'Web search via Brave Search API',
+                    autoConnect: false,
+                    env: {
+                        BRAVE_API_KEY: process.env.BRAVE_API_KEY || ''
+                    }
+                },
+                {
+                    name: 'Slack',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-slack'],
+                    description: 'Slack workspace integration',
+                    autoConnect: false,
+                    env: {
+                        SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN || ''
+                    }
+                }
+            ]
+        };
+    }
+
+    public getConfig(): McpConfig {
+        return this.config;
+    }
+
+    public saveConfig(): void {
+        try {
+            const dir = join(homedir(), '.mentis');
+            if (!existsSync(dir)) {
+                require('fs').mkdirSync(dir, { recursive: true });
+            }
+            writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+        } catch (error) {
+            console.error('Failed to save MCP config:', error);
+        }
+    }
+
+    public addServer(server: McpServerConfig): void {
+        // Remove existing server with same name
+        this.config.servers = this.config.servers.filter(s => s.name !== server.name);
+        this.config.servers.push(server);
+        this.saveConfig();
+    }
+
+    public removeServer(name: string): void {
+        this.config.servers = this.config.servers.filter(s => s.name !== name);
+        this.saveConfig();
+    }
+
+    public getServer(name: string): McpServerConfig | undefined {
+        return this.config.servers.find(s => s.name === name);
+    }
+
+    public getAutoConnectServers(): McpServerConfig[] {
+        return this.config.servers.filter(s => s.autoConnect === true);
+    }
+
+    public updateServer(name: string, updates: Partial<McpServerConfig>): void {
+        const server = this.config.servers.find(s => s.name === name);
+        if (server) {
+            Object.assign(server, updates);
+            this.saveConfig();
+        }
+    }
+}

package/src/mcp/McpManager.ts

@@ -0,0 +1,224 @@
+import { McpClient } from './McpClient';
+import { McpConfigManager, McpServerConfig } from './McpConfig';
+import { Tool } from '../tools/Tool';
+import ora from 'ora';
+import chalk from 'chalk';
+
+export interface McpConnection {
+    client: McpClient;
+    config: McpServerConfig;
+    tools: Tool[];
+    connectedAt: Date;
+}
+
+export class McpManager {
+    private configManager: McpConfigManager;
+    private connections: Map<string, McpConnection> = new Map();
+
+    constructor() {
+        this.configManager = new McpConfigManager();
+    }
+
+    public getConfig(): McpConfigManager {
+        return this.configManager;
+    }
+
+    public async connectToServer(serverName: string): Promise<McpConnection | null> {
+        const config = this.configManager.getServer(serverName);
+        if (!config) {
+            console.error(chalk.red(`MCP server "${serverName}" not found in configuration`));
+            return null;
+        }
+
+        // Check if already connected
+        if (this.connections.has(serverName)) {
+            console.log(chalk.yellow(`Already connected to ${serverName}`));
+            return this.connections.get(serverName)!;
+        }
+
+        const spinner = ora(`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.yellow(`Environment variable ${key} is required for ${serverName}`));
+                        console.log(chalk.dim(`Set it with: export ${key}=your_key`));
+                        console.log(chalk.dim(`Or add it to your MCP configuration`));
+                    }
+                }
+            }
+
+            const client = new McpClient(config.command, config.args);
+            await client.initialize();
+            const tools = await client.listTools();
+
+            const connection: McpConnection = {
+                client,
+                config,
+                tools,
+                connectedAt: new Date()
+            };
+
+            this.connections.set(serverName, connection);
+
+            spinner.succeed(chalk.green(`Connected to ${client.serverName}!`));
+            
+            if (tools.length > 0) {
+                console.log(chalk.green(`Added ${tools.length} tools:`));
+                tools.forEach(t => {
+                    const description = t.description.length > 60 
+                        ? t.description.substring(0, 60) + '...' 
+                        : t.description;
+                    console.log(chalk.dim(`  - ${chalk.cyan(t.name)}: ${description}`));
+                });
+            } else {
+                console.log(chalk.yellow('No tools available from this server'));
+            }
+
+            return connection;
+
+        } catch (error: any) {
+            spinner.fail(chalk.red(`Failed to connect to ${serverName}: ${error.message}`));
+            return null;
+        }
+    }
+
+    public async disconnectFromServer(serverName: string): Promise<boolean> {
+        const connection = this.connections.get(serverName);
+        if (!connection) {
+            console.log(chalk.yellow(`Not connected to ${serverName}`));
+            return false;
+        }
+
+        try {
+            connection.client.disconnect();
+            this.connections.delete(serverName);
+            console.log(chalk.green(`Disconnected from ${serverName}`));
+            return true;
+        } catch (error: any) {
+            console.error(chalk.red(`Error disconnecting from ${serverName}: ${error.message}`));
+            return false;
+        }
+    }
+
+    public disconnectAll(): void {
+        const serverNames = Array.from(this.connections.keys());
+        for (const name of serverNames) {
+            this.disconnectFromServer(name);
+        }
+    }
+
+    public getConnections(): McpConnection[] {
+        return Array.from(this.connections.values());
+    }
+
+    public getConnection(name: string): McpConnection | undefined {
+        return this.connections.get(name);
+    }
+
+    public getAllTools(): Tool[] {
+        const allTools: Tool[] = [];
+        for (const connection of this.connections.values()) {
+            allTools.push(...connection.tools);
+        }
+        return allTools;
+    }
+
+    public getServerNames(): string[] {
+        return Array.from(this.connections.keys());
+    }
+
+    public getAvailableServers(): McpServerConfig[] {
+        return this.configManager.getConfig().servers;
+    }
+
+    public async autoConnect(): Promise<void> {
+        const autoConnectServers = this.configManager.getAutoConnectServers();
+        
+        if (autoConnectServers.length === 0) {
+            return;
+        }
+
+        console.log(chalk.blue(`\nAuto-connecting to ${autoConnectServers.length} MCP servers...`));
+        
+        for (const config of autoConnectServers) {
+            await this.connectToServer(config.name);
+        }
+    }
+
+    public async listServers(): Promise<void> {
+        const availableServers = this.configManager.getConfig().servers;
+        const connectedServers = this.getServerNames();
+
+        if (availableServers.length === 0) {
+            console.log(chalk.yellow('No MCP servers configured.'));
+            return;
+        }
+
+        console.log(chalk.cyan('\nMCP Servers:\n'));
+
+        for (const server of availableServers) {
+            const isConnected = connectedServers.includes(server.name);
+            const status = isConnected ? chalk.green('● Connected') : chalk.gray('○ Disconnected');
+            const auto = server.autoConnect ? chalk.dim('[auto]') : '';
+            
+            console.log(`${status} ${chalk.bold(server.name)} ${auto}`);
+            if (server.description) {
+                console.log(chalk.dim(`  ${server.description}`));
+            }
+            
+            if (isConnected) {
+                const connection = this.getConnection(server.name);
+                if (connection && connection.tools.length > 0) {
+                    console.log(chalk.dim(`  Tools: ${connection.tools.map(t => t.name).join(', ')}`));
+                }
+            }
+            console.log('');
+        }
+    }
+
+    public async addServer(name: string, command: string, args: string[], description?: string): Promise<void> {
+        const serverConfig: McpServerConfig = {
+            name,
+            command,
+            args,
+            description,
+            autoConnect: false
+        };
+
+        this.configManager.addServer(serverConfig);
+        console.log(chalk.green(`Added MCP server "${name}" to configuration`));
+    }
+
+    public async removeServer(name: string): Promise<void> {
+        // Disconnect if connected
+        if (this.connections.has(name)) {
+            await this.disconnectFromServer(name);
+        }
+
+        this.configManager.removeServer(name);
+        console.log(chalk.green(`Removed MCP server "${name}" from configuration`));
+    }
+
+    public async testConnection(serverName: string): Promise<boolean> {
+        const connection = this.getConnection(serverName);
+        if (!connection) {
+            console.log(chalk.red(`Not connected to ${serverName}`));
+            return false;
+        }
+
+        try {
+            // Try to list tools as a test
+            await connection.client.listTools();
+            console.log(chalk.green(`${serverName} connection is healthy`));
+            return true;
+        } catch (error: any) {
+            console.log(chalk.red(`${serverName} connection test failed: ${error.message}`));
+            return false;
+        }
+    }
+}

package/src/repl/PersistentShell.ts

@@ -7,6 +7,7 @@ export class PersistentShell {
     private delimiter: string = 'MENTIS_SHELL_DELIMITER';
     private resolveCallback: ((output: string) => void) | null = null;
     private rejectCallback: ((error: Error) => void) | null = null;
+    private readonly COMMAND_TIMEOUT = 120000; // 2 minutes timeout for shell commands
 
     constructor() {
         // Lazy init: Do not spawn here.
@@ -68,7 +69,29 @@ export class PersistentShell {
             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: string) => {
+                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.platform() === 'win32') {
+                cleanCommand = cleanCommand.replace(/(^|[\s|;&])curl(\s|$)/g, '$1curl.exe$2');
+            }
 
             const fullCommand = `${cleanCommand}; echo "${this.delimiter}"\n`;