agentstudio 0.1.0

package/dist/routes/mcp.js

@@ -0,0 +1,652 @@
+import express from 'express';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+const router = express.Router();
+const execAsync = promisify(exec);
+// Helper function to get MCP config file path
+const getMcpConfigPath = () => {
+    return path.join(os.homedir(), '.claude-agent', 'mcp-server.json');
+};
+// Helper function to ensure config directory exists
+const ensureConfigDirectory = () => {
+    const configDir = path.dirname(getMcpConfigPath());
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+};
+// Helper function to read MCP config
+const readMcpConfig = () => {
+    const configPath = getMcpConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return { mcpServers: {} };
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.error('Failed to read MCP config:', error);
+        return { mcpServers: {} };
+    }
+};
+// Helper function to write MCP config
+const writeMcpConfig = (config) => {
+    ensureConfigDirectory();
+    const configPath = getMcpConfigPath();
+    try {
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    catch (error) {
+        console.error('Failed to write MCP config:', error);
+        throw error;
+    }
+};
+// Get all MCP configurations
+router.get('/', (req, res) => {
+    try {
+        const config = readMcpConfig();
+        const servers = Object.entries(config.mcpServers).map(([name, serverConfig]) => ({
+            name,
+            ...serverConfig
+        }));
+        res.json({ servers });
+    }
+    catch (error) {
+        console.error('Failed to get MCP configs:', error);
+        res.status(500).json({ error: 'Failed to retrieve MCP configurations' });
+    }
+});
+// Add or update MCP configuration
+router.post('/', (req, res) => {
+    try {
+        const { name, type, command, args, url, timeout, autoApprove } = req.body;
+        if (!name || !type) {
+            return res.status(400).json({ error: 'Missing required fields: name, type' });
+        }
+        // Validate based on type
+        if (type === 'stdio') {
+            if (!command || !Array.isArray(args)) {
+                return res.status(400).json({ error: 'For stdio type: command and args are required' });
+            }
+        }
+        else if (type === 'http') {
+            if (!url) {
+                return res.status(400).json({ error: 'For http type: url is required' });
+            }
+        }
+        else {
+            return res.status(400).json({ error: 'Invalid type. Must be "stdio" or "http"' });
+        }
+        const config = readMcpConfig();
+        // Create server config without name field
+        const serverConfig = {
+            type,
+            ...(command && { command }),
+            ...(args && { args }),
+            ...(url && { url }),
+            ...(timeout && { timeout }),
+            ...(autoApprove && Array.isArray(autoApprove) && { autoApprove })
+        };
+        config.mcpServers[name] = serverConfig;
+        writeMcpConfig(config);
+        const responseServer = { name, ...serverConfig };
+        res.json({ server: responseServer, message: 'MCP configuration saved successfully' });
+    }
+    catch (error) {
+        console.error('Failed to save MCP config:', error);
+        res.status(500).json({ error: 'Failed to save MCP configuration' });
+    }
+});
+// Update MCP configuration
+router.put('/:name', (req, res) => {
+    try {
+        const { name } = req.params;
+        const { type, command, args, url, timeout, autoApprove } = req.body;
+        if (!type) {
+            return res.status(400).json({ error: 'Missing required field: type' });
+        }
+        // Validate based on type
+        if (type === 'stdio') {
+            if (!command || !Array.isArray(args)) {
+                return res.status(400).json({ error: 'For stdio type: command and args are required' });
+            }
+        }
+        else if (type === 'http') {
+            if (!url) {
+                return res.status(400).json({ error: 'For http type: url is required' });
+            }
+        }
+        else {
+            return res.status(400).json({ error: 'Invalid type. Must be "stdio" or "http"' });
+        }
+        const config = readMcpConfig();
+        if (!config.mcpServers[name]) {
+            return res.status(404).json({ error: 'MCP configuration not found' });
+        }
+        // Update server config
+        const serverConfig = {
+            type,
+            ...(command && { command }),
+            ...(args && { args }),
+            ...(url && { url }),
+            ...(timeout && { timeout }),
+            ...(autoApprove && Array.isArray(autoApprove) && { autoApprove })
+        };
+        config.mcpServers[name] = serverConfig;
+        writeMcpConfig(config);
+        const responseServer = { name, ...serverConfig };
+        res.json({ server: responseServer, message: 'MCP configuration updated successfully' });
+    }
+    catch (error) {
+        console.error('Failed to update MCP config:', error);
+        res.status(500).json({ error: 'Failed to update MCP configuration' });
+    }
+});
+// Delete MCP configuration
+router.delete('/:name', (req, res) => {
+    try {
+        const { name } = req.params;
+        const config = readMcpConfig();
+        if (!config.mcpServers[name]) {
+            return res.status(404).json({ error: 'MCP configuration not found' });
+        }
+        delete config.mcpServers[name];
+        writeMcpConfig(config);
+        res.json({ success: true, message: 'MCP configuration deleted successfully' });
+    }
+    catch (error) {
+        console.error('Failed to delete MCP config:', error);
+        res.status(500).json({ error: 'Failed to delete MCP configuration' });
+    }
+});
+// Validate MCP server by testing connection and getting tools
+router.post('/:name/validate', async (req, res) => {
+    try {
+        const { name } = req.params;
+        const config = readMcpConfig();
+        if (!config.mcpServers[name]) {
+            return res.status(404).json({ error: 'MCP configuration not found' });
+        }
+        const serverConfig = config.mcpServers[name];
+        if (serverConfig.type === 'http') {
+            // Validate HTTP MCP server
+            await validateHttpMcpServer(name, serverConfig, config, res);
+        }
+        else if (serverConfig.type === 'stdio') {
+            // Validate stdio MCP server
+            await validateStdioMcpServer(name, serverConfig, config, res);
+        }
+        else {
+            res.status(400).json({ error: 'Invalid MCP server type' });
+        }
+    }
+    catch (error) {
+        console.error('Failed to validate MCP server:', error);
+        res.status(500).json({
+            error: 'Failed to validate MCP server',
+            details: error instanceof Error ? error.message : String(error)
+        });
+    }
+});
+// Get MCP configurations from Claude Code CLI
+router.get('/claude-code', async (req, res) => {
+    try {
+        // Try to get MCP servers from Claude Code CLI
+        const { stdout } = await execAsync('claude mcp list');
+        // Parse the output to extract MCP server information
+        const lines = stdout.split('\n').filter(line => line.trim());
+        const servers = [];
+        for (const line of lines) {
+            // Look for lines that contain MCP server information
+            // Format: "server-name: url (TYPE) - ✓ Connected" or "server-name: url (TYPE) - ✗ Error"
+            const match = line.match(/^(.+?):\s+(.+?)\s+\((\w+)\)\s+-\s+(✓|✗)\s+(.+)$/);
+            if (match) {
+                const [, name, urlOrCommand, type, status, statusText] = match;
+                const server = {
+                    name: name.trim(),
+                    type: type.toLowerCase() === 'http' ? 'http' : 'stdio',
+                    status: status === '✓' ? 'active' : 'error'
+                };
+                if (server.type === 'http') {
+                    server.url = urlOrCommand.trim();
+                }
+                else {
+                    // For stdio, we might need to parse command and args
+                    // This is a simplified approach
+                    const parts = urlOrCommand.trim().split(' ');
+                    server.command = parts[0];
+                    server.args = parts.slice(1);
+                }
+                if (status === '✗') {
+                    server.error = statusText;
+                }
+                servers.push(server);
+            }
+        }
+        res.json({ servers });
+    }
+    catch (error) {
+        console.error('Failed to get Claude Code MCP configurations:', error);
+        res.status(500).json({
+            error: 'Failed to get Claude Code MCP configurations',
+            details: error instanceof Error ? error.message : String(error)
+        });
+    }
+});
+export default router;
+// Validate HTTP MCP server
+async function validateHttpMcpServer(name, serverConfig, config, res) {
+    try {
+        console.log('Validating HTTP MCP server:', serverConfig.url);
+        // Test HTTP connection to MCP server
+        const response = await fetch(serverConfig.url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json, text/event-stream',
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'initialize',
+                params: {
+                    protocolVersion: '2024-11-05',
+                    capabilities: {
+                        tools: {}
+                    },
+                    clientInfo: {
+                        name: 'claude-code-studio',
+                        version: '1.0.0'
+                    }
+                }
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        // Parse SSE response
+        const responseText = await response.text();
+        console.log('HTTP MCP initialize response text:', responseText);
+        // Extract JSON from SSE format
+        let initResult = null;
+        const lines = responseText.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('data: ')) {
+                try {
+                    initResult = JSON.parse(line.substring(6));
+                    break;
+                }
+                catch (e) {
+                    console.warn('Failed to parse SSE data line:', line);
+                }
+            }
+        }
+        if (!initResult) {
+            throw new Error('Failed to parse HTTP MCP response');
+        }
+        console.log('HTTP MCP initialize parsed result:', initResult);
+        // Get tools from HTTP MCP server using proper session management
+        let tools = [];
+        console.log('Getting tools from HTTP MCP server...');
+        try {
+            tools = await getHttpMcpTools(serverConfig.url);
+            console.log('Successfully retrieved tools from HTTP MCP:', tools);
+        }
+        catch (error) {
+            console.warn('Failed to get tools from HTTP MCP server:', error);
+            // Don't fail validation just because tools retrieval failed
+        }
+        // Update server config with successful validation
+        const currentTime = new Date().toISOString();
+        if (config.mcpServers[name]) {
+            config.mcpServers[name] = {
+                ...config.mcpServers[name],
+                status: 'active',
+                tools,
+                lastValidated: currentTime,
+                error: undefined
+            };
+            writeMcpConfig(config);
+        }
+        res.json({
+            success: true,
+            tools,
+            message: `HTTP MCP server validated successfully. Found ${tools.length} tools.`
+        });
+    }
+    catch (error) {
+        console.error('HTTP MCP server validation failed:', error);
+        // Update server config with error status
+        const currentTime = new Date().toISOString();
+        if (config.mcpServers[name]) {
+            config.mcpServers[name] = {
+                ...config.mcpServers[name],
+                status: 'error',
+                error: error instanceof Error ? error.message : String(error),
+                tools: undefined,
+                lastValidated: currentTime
+            };
+            writeMcpConfig(config);
+        }
+        res.status(400).json({
+            error: 'HTTP MCP server validation failed',
+            details: error instanceof Error ? error.message : String(error)
+        });
+    }
+}
+// Validate stdio MCP server
+async function validateStdioMcpServer(name, serverConfig, config, res) {
+    if (!serverConfig.command || !serverConfig.args) {
+        return res.status(400).json({ error: 'Missing command or args for stdio MCP server' });
+    }
+    // Start MCP server process to test connection
+    console.log('Starting stdio MCP server:', serverConfig.command, serverConfig.args);
+    const child = spawn(serverConfig.command, serverConfig.args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: serverConfig.timeout || 15000
+    });
+    let stdout = '';
+    let stderr = '';
+    let tools = [];
+    child.stderr?.on('data', (data) => {
+        const errorStr = data.toString();
+        console.log('MCP stderr:', errorStr);
+        stderr += errorStr;
+    });
+    let initializeDone = false;
+    // Send initialize request to MCP server
+    const initializeRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+            protocolVersion: '2024-11-05',
+            capabilities: {
+                tools: {}
+            },
+            clientInfo: {
+                name: 'claude-code-studio',
+                version: '1.0.0'
+            }
+        }
+    };
+    child.stdin?.write(JSON.stringify(initializeRequest) + '\n');
+    let buffer = '';
+    // Listen for stdout and parse responses in real-time
+    child.stdout?.on('data', (data) => {
+        const dataStr = data.toString();
+        stdout += dataStr;
+        buffer += dataStr;
+        // Try to parse complete JSON messages
+        const lines = buffer.split('\n');
+        // Keep the last incomplete line in the buffer
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const response = JSON.parse(line);
+                console.log('MCP response:', response);
+                // Check if initialization was successful
+                if (response.id === 1 && response.result && !initializeDone) {
+                    console.log('Initialize successful, sending initialized notification');
+                    initializeDone = true;
+                    // Send initialized notification
+                    const initializedNotification = {
+                        jsonrpc: '2.0',
+                        method: 'notifications/initialized'
+                    };
+                    child.stdin?.write(JSON.stringify(initializedNotification) + '\n');
+                    // Send tools/list request
+                    setTimeout(() => {
+                        console.log('Sending tools/list request');
+                        const toolsRequest = {
+                            jsonrpc: '2.0',
+                            id: 2,
+                            method: 'tools/list',
+                            params: {}
+                        };
+                        child.stdin?.write(JSON.stringify(toolsRequest) + '\n');
+                    }, 500);
+                }
+                // Handle tools/list response
+                if (response.id === 2 && response.result) {
+                    console.log('Tools/list response received:', response.result);
+                    if (response.result.tools) {
+                        tools = response.result.tools.map((tool) => tool.name);
+                        console.log('Found tools:', tools);
+                    }
+                    // Close stdin after getting tools response (even if empty)
+                    setTimeout(() => child.stdin?.end(), 100);
+                }
+            }
+            catch (parseError) {
+                // This might be a partial JSON, continue buffering
+                console.log('Parse error for line:', line.substring(0, 100) + '...');
+            }
+        }
+        // Also try to parse the buffer as a complete JSON in case it's all one response
+        if (buffer.trim()) {
+            try {
+                const response = JSON.parse(buffer);
+                console.log('MCP buffered response:', response);
+                // Handle tools/list response from buffer
+                if (response.id === 2 && response.result) {
+                    console.log('Tools/list response received from buffer:', response.result);
+                    if (response.result.tools) {
+                        tools = response.result.tools.map((tool) => tool.name);
+                        console.log('Found tools from buffer:', tools);
+                    }
+                    // Clear buffer and close stdin
+                    buffer = '';
+                    setTimeout(() => child.stdin?.end(), 100);
+                }
+            }
+            catch (parseError) {
+                // Buffer is not complete JSON yet, continue
+            }
+        }
+    });
+    const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+    }, serverConfig.timeout || 10000);
+    child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        try {
+            const config = readMcpConfig();
+            const currentTime = new Date().toISOString();
+            if (code === 0 || tools.length > 0) {
+                // Update server config with successful validation
+                if (config.mcpServers[name]) {
+                    config.mcpServers[name] = {
+                        ...config.mcpServers[name],
+                        status: 'active',
+                        tools,
+                        lastValidated: currentTime,
+                        error: undefined
+                    };
+                    writeMcpConfig(config);
+                }
+                res.json({
+                    success: true,
+                    tools,
+                    message: `MCP server validated successfully. Found ${tools.length} tools.`
+                });
+            }
+            else {
+                // Update server config with error status
+                const errorMessage = `MCP server validation failed with exit code ${code}`;
+                if (config.mcpServers[name]) {
+                    config.mcpServers[name] = {
+                        ...config.mcpServers[name],
+                        status: 'error',
+                        error: errorMessage,
+                        tools: undefined,
+                        lastValidated: currentTime
+                    };
+                    writeMcpConfig(config);
+                }
+                res.status(400).json({
+                    error: errorMessage,
+                    details: stderr || 'No error details available'
+                });
+            }
+        }
+        catch (configError) {
+            console.error('Failed to update config with validation result:', configError);
+            // Still return the validation result even if config update fails
+            if (code === 0 || tools.length > 0) {
+                res.json({
+                    success: true,
+                    tools,
+                    message: `MCP server validated successfully. Found ${tools.length} tools.`
+                });
+            }
+            else {
+                res.status(400).json({
+                    error: `MCP server validation failed with exit code ${code}`,
+                    details: stderr || 'No error details available'
+                });
+            }
+        }
+    });
+    child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        try {
+            const config = readMcpConfig();
+            if (config.mcpServers[name]) {
+                config.mcpServers[name] = {
+                    ...config.mcpServers[name],
+                    status: 'error',
+                    error: `Failed to start MCP server: ${error.message}`,
+                    tools: undefined,
+                    lastValidated: new Date().toISOString()
+                };
+                writeMcpConfig(config);
+            }
+        }
+        catch (configError) {
+            console.error('Failed to update config with error status:', configError);
+        }
+        res.status(500).json({
+            error: 'Failed to start MCP server',
+            details: error.message
+        });
+    });
+}
+/**
+ * Get tools from HTTP MCP server using proper session management
+ * HTTP MCP requires maintaining session state between initialize and tools/list calls
+ */
+async function getHttpMcpTools(url) {
+    console.log('Starting HTTP MCP tools discovery for:', url);
+    // Step 1: Initialize the session
+    const initResponse = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json, text/event-stream',
+        },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'initialize',
+            params: {
+                protocolVersion: '2024-11-05',
+                capabilities: {
+                    tools: {}
+                },
+                clientInfo: {
+                    name: 'agentstudio-validator',
+                    version: '1.0.0'
+                }
+            }
+        })
+    });
+    if (!initResponse.ok) {
+        throw new Error(`HTTP MCP initialize failed: ${initResponse.status} ${initResponse.statusText}`);
+    }
+    const initResponseText = await initResponse.text();
+    console.log('HTTP MCP initialize response:', initResponseText);
+    // Parse initialize response
+    let initResult = null;
+    const initLines = initResponseText.split('\n');
+    for (const line of initLines) {
+        if (line.startsWith('data: ')) {
+            try {
+                initResult = JSON.parse(line.substring(6));
+                break;
+            }
+            catch (e) {
+                console.warn('Failed to parse init SSE data line:', line);
+            }
+        }
+    }
+    if (!initResult || !initResult.result) {
+        throw new Error('Invalid initialize response from HTTP MCP server');
+    }
+    // Extract session ID from response headers
+    const sessionId = initResponse.headers.get('mcp-session-id');
+    console.log('HTTP MCP session ID:', sessionId);
+    // Step 2: Get tools list using the session ID
+    // Wait a bit to ensure the session is properly established
+    await new Promise(resolve => setTimeout(resolve, 100));
+    const toolsHeaders = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json, text/event-stream',
+    };
+    // Add session ID if available
+    if (sessionId) {
+        toolsHeaders['mcp-session-id'] = sessionId;
+    }
+    // Copy any session cookies from the init response
+    if (initResponse.headers.get('set-cookie')) {
+        toolsHeaders['Cookie'] = initResponse.headers.get('set-cookie');
+    }
+    const toolsResponse = await fetch(url, {
+        method: 'POST',
+        headers: toolsHeaders,
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: 2,
+            method: 'tools/list',
+            params: {}
+        })
+    });
+    if (!toolsResponse.ok) {
+        throw new Error(`HTTP MCP tools/list failed: ${toolsResponse.status} ${toolsResponse.statusText}`);
+    }
+    const toolsResponseText = await toolsResponse.text();
+    console.log('HTTP MCP tools/list response:', toolsResponseText);
+    // Parse tools response
+    let toolsResult = null;
+    const toolsLines = toolsResponseText.split('\n');
+    for (const line of toolsLines) {
+        if (line.startsWith('data: ')) {
+            try {
+                toolsResult = JSON.parse(line.substring(6));
+                break;
+            }
+            catch (e) {
+                console.warn('Failed to parse tools SSE data line:', line);
+            }
+        }
+    }
+    if (!toolsResult) {
+        throw new Error('Invalid tools/list response from HTTP MCP server');
+    }
+    if (toolsResult.error) {
+        throw new Error(`HTTP MCP tools/list error: ${toolsResult.error.message}`);
+    }
+    if (!toolsResult.result || !toolsResult.result.tools) {
+        console.log('HTTP MCP server returned no tools');
+        return [];
+    }
+    const tools = toolsResult.result.tools.map((tool) => tool.name);
+    console.log('Extracted tools from HTTP MCP:', tools);
+    return tools;
+}
+//# sourceMappingURL=mcp.js.map