@probelabs/probe 0.6.0-rc100

package/build/agent/mcp/client.js

@@ -0,0 +1,338 @@
+/**
+ * Enhanced MCP Client with support for all transport types
+ * Compatible with Claude's MCP configuration format
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/websocket.js';
+import { loadMCPConfiguration, parseEnabledServers } from './config.js';
+
+/**
+ * Create transport based on configuration
+ * @param {Object} serverConfig - Server configuration
+ * @returns {Object} Transport instance
+ */
+export function createTransport(serverConfig) {
+  const { transport, command, args, url, env } = serverConfig;
+
+  switch (transport) {
+    case 'stdio':
+      return new StdioClientTransport({
+        command,
+        args: args || [],
+        env: env ? { ...process.env, ...env } : undefined
+      });
+
+    case 'sse':
+      if (!url) {
+        throw new Error('SSE transport requires a URL');
+      }
+      return new SSEClientTransport(new URL(url));
+
+    case 'websocket':
+    case 'ws':
+      if (!url) {
+        throw new Error('WebSocket transport requires a URL');
+      }
+      try {
+        return new WebSocketClientTransport(new URL(url));
+      } catch (error) {
+        throw new Error(`Invalid WebSocket URL: ${url}`);
+      }
+
+    case 'http':
+    case 'streamable':
+      // For HTTP, we'll use a custom implementation since the SDK
+      // doesn't provide a direct HTTP transport yet
+      if (!url) {
+        throw new Error('HTTP transport requires a URL');
+      }
+      // Return a custom HTTP transport wrapper
+      return createHttpTransport(url);
+
+    default:
+      throw new Error(`Unknown transport type: ${transport}`);
+  }
+}
+
+/**
+ * Create a custom HTTP transport wrapper
+ * This simulates MCP over HTTP REST endpoints
+ */
+function createHttpTransport(url) {
+  // This is a simplified HTTP transport
+  // In practice, you'd implement the full MCP protocol over HTTP
+  return {
+    async start() {
+      // Initialize HTTP connection
+      const response = await fetch(`${url}/initialize`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          protocolVersion: '2024-11-05',
+          capabilities: {}
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP initialization failed: ${response.statusText}`);
+      }
+
+      return response.json();
+    },
+
+    async send(message) {
+      const response = await fetch(`${url}/message`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(message)
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP request failed: ${response.statusText}`);
+      }
+
+      return response.json();
+    },
+
+    async close() {
+      // Close HTTP connection
+      await fetch(`${url}/close`, {
+        method: 'POST'
+      }).catch(() => {
+        // Ignore close errors
+      });
+    }
+  };
+}
+
+/**
+ * MCP Client Manager - manages multiple MCP server connections
+ */
+export class MCPClientManager {
+  constructor(options = {}) {
+    this.clients = new Map();
+    this.tools = new Map();
+    this.debug = options.debug || process.env.DEBUG_MCP === '1';
+    this.config = null;
+  }
+
+  /**
+   * Initialize MCP clients from configuration
+   * @param {Object} config - Optional configuration override
+   */
+  async initialize(config = null) {
+    // Load configuration
+    this.config = config || loadMCPConfiguration();
+    const servers = parseEnabledServers(this.config);
+
+    if (this.debug) {
+      console.error(`[MCP] Found ${servers.length} enabled servers`);
+    }
+
+    // Connect to each enabled server
+    const connectionPromises = servers.map(server =>
+      this.connectToServer(server).catch(error => {
+        console.error(`[MCP] Failed to connect to ${server.name}:`, error.message);
+        return null;
+      })
+    );
+
+    const results = await Promise.all(connectionPromises);
+    const connectedCount = results.filter(Boolean).length;
+
+    if (this.debug) {
+      console.error(`[MCP] Successfully connected to ${connectedCount}/${servers.length} servers`);
+      console.error(`[MCP] Total tools available: ${this.tools.size}`);
+    }
+
+    return {
+      connected: connectedCount,
+      total: servers.length,
+      tools: Array.from(this.tools.keys())
+    };
+  }
+
+  /**
+   * Connect to a single MCP server
+   * @param {Object} serverConfig - Server configuration
+   */
+  async connectToServer(serverConfig) {
+    const { name } = serverConfig;
+
+    try {
+      if (this.debug) {
+        console.error(`[MCP] Connecting to ${name} via ${serverConfig.transport}...`);
+      }
+
+      // Create transport
+      const transport = createTransport(serverConfig);
+
+      // Create client
+      const client = new Client(
+        {
+          name: `probe-client-${name}`,
+          version: '1.0.0'
+        },
+        {
+          capabilities: {}
+        }
+      );
+
+      // Connect
+      await client.connect(transport);
+
+      // Store client
+      this.clients.set(name, {
+        client,
+        transport,
+        config: serverConfig
+      });
+
+      // Fetch and register tools
+      const toolsResponse = await client.listTools();
+
+      if (toolsResponse && toolsResponse.tools) {
+        for (const tool of toolsResponse.tools) {
+          // Add server prefix to avoid conflicts
+          const qualifiedName = `${name}_${tool.name}`;
+          this.tools.set(qualifiedName, {
+            ...tool,
+            serverName: name,
+            originalName: tool.name
+          });
+
+          if (this.debug) {
+            console.error(`[MCP]   Registered tool: ${qualifiedName}`);
+          }
+        }
+      }
+
+      if (this.debug) {
+        console.error(`[MCP] Connected to ${name} with ${toolsResponse?.tools?.length || 0} tools`);
+      }
+
+      return true;
+    } catch (error) {
+      console.error(`[MCP] Error connecting to ${name}:`, error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Call a tool on its respective server
+   * @param {string} toolName - Qualified tool name (server_tool)
+   * @param {Object} args - Tool arguments
+   */
+  async callTool(toolName, args) {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      throw new Error(`Unknown tool: ${toolName}`);
+    }
+
+    const clientInfo = this.clients.get(tool.serverName);
+    if (!clientInfo) {
+      throw new Error(`Server ${tool.serverName} not connected`);
+    }
+
+    try {
+      if (this.debug) {
+        console.error(`[MCP] Calling ${toolName} with args:`, args);
+      }
+
+      const result = await clientInfo.client.callTool({
+        name: tool.originalName,
+        arguments: args
+      });
+
+      return result;
+    } catch (error) {
+      console.error(`[MCP] Error calling tool ${toolName}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get all available tools with their schemas
+   * @returns {Object} Map of tool name to tool definition
+   */
+  getTools() {
+    const tools = {};
+    for (const [name, tool] of this.tools.entries()) {
+      tools[name] = {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        serverName: tool.serverName
+      };
+    }
+    return tools;
+  }
+
+  /**
+   * Get tools formatted for Vercel AI SDK
+   * @returns {Object} Tools in Vercel AI SDK format
+   */
+  getVercelTools() {
+    const tools = {};
+
+    for (const [name, tool] of this.tools.entries()) {
+      // Create a wrapper that calls the MCP tool
+      tools[name] = {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        execute: async (args) => {
+          const result = await this.callTool(name, args);
+          // Extract text content from MCP response
+          if (result.content && result.content[0]) {
+            return result.content[0].text;
+          }
+          return JSON.stringify(result);
+        }
+      };
+    }
+
+    return tools;
+  }
+
+  /**
+   * Disconnect all clients
+   */
+  async disconnect() {
+    const disconnectPromises = [];
+
+    for (const [name, clientInfo] of this.clients.entries()) {
+      disconnectPromises.push(
+        clientInfo.client.close()
+          .then(() => {
+            if (this.debug) {
+              console.error(`[MCP] Disconnected from ${name}`);
+            }
+          })
+          .catch(error => {
+            console.error(`[MCP] Error disconnecting from ${name}:`, error);
+          })
+      );
+    }
+
+    await Promise.all(disconnectPromises);
+    this.clients.clear();
+    this.tools.clear();
+  }
+}
+
+/**
+ * Create and initialize MCP client manager with default configuration
+ */
+export async function createMCPManager(options = {}) {
+  const manager = new MCPClientManager(options);
+  await manager.initialize();
+  return manager;
+}
+
+export default {
+  MCPClientManager,
+  createMCPManager,
+  createTransport
+};

package/build/agent/mcp/config.js

@@ -0,0 +1,313 @@
+/**
+ * MCP Configuration Manager
+ * Handles loading and parsing MCP server configurations similar to Claude
+ */
+
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Default MCP configuration structure
+ */
+const DEFAULT_CONFIG = {
+  mcpServers: {
+    // Example probe server configuration
+    'probe-local': {
+      command: 'node',
+      args: [join(__dirname, '../../../examples/chat/mcpServer.js')],
+      transport: 'stdio',
+      enabled: false
+    },
+    'probe-npm': {
+      command: 'npx',
+      args: ['-y', '@probelabs/probe@latest', 'mcp'],
+      transport: 'stdio',
+      enabled: false
+    }
+  }
+};
+
+/**
+ * Load MCP configuration from a specific file path
+ * @param {string} configPath - Path to MCP configuration file
+ * @returns {Object} Configuration object
+ * @throws {Error} If file doesn't exist or is invalid
+ */
+export function loadMCPConfigurationFromPath(configPath) {
+  if (!configPath) {
+    throw new Error('Config path is required');
+  }
+
+  if (!existsSync(configPath)) {
+    throw new Error(`MCP configuration file not found: ${configPath}`);
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf8');
+    const config = JSON.parse(content);
+
+    if (process.env.DEBUG === '1') {
+      console.error(`[MCP] Loaded configuration from: ${configPath}`);
+    }
+
+    // Merge with environment variable overrides
+    return mergeWithEnvironment(config);
+  } catch (error) {
+    throw new Error(`Failed to parse MCP config from ${configPath}: ${error.message}`);
+  }
+}
+
+/**
+ * Load MCP configuration from various sources (DEPRECATED - use loadMCPConfigurationFromPath for explicit paths)
+ * Priority order:
+ * 1. Environment variable MCP_CONFIG_PATH
+ * 2. Local project .mcp/config.json
+ * 3. Home directory ~/.config/probe/mcp.json
+ * 4. Home directory ~/.mcp/config.json (Claude compatible)
+ * 5. Default configuration
+ * @deprecated Use loadMCPConfigurationFromPath for explicit path loading or pass config directly
+ */
+export function loadMCPConfiguration() {
+  const configPaths = [
+    // Environment variable path
+    process.env.MCP_CONFIG_PATH,
+    // Local project paths
+    join(process.cwd(), '.mcp', 'config.json'),
+    join(process.cwd(), 'mcp.config.json'),
+    // Home directory paths
+    join(homedir(), '.config', 'probe', 'mcp.json'),
+    join(homedir(), '.mcp', 'config.json'),
+    // Claude-style config location
+    join(homedir(), 'Library', 'Application Support', 'Claude', 'mcp_config.json'),
+  ].filter(Boolean);
+
+  let config = null;
+
+  // Try to load configuration from paths
+  for (const configPath of configPaths) {
+    if (existsSync(configPath)) {
+      try {
+        const content = readFileSync(configPath, 'utf8');
+        config = JSON.parse(content);
+        if (process.env.DEBUG === '1') {
+          console.error(`[MCP] Loaded configuration from: ${configPath}`);
+        }
+        break;
+      } catch (error) {
+        console.error(`[MCP] Failed to parse config from ${configPath}:`, error.message);
+      }
+    }
+  }
+
+  // Merge with environment variable overrides
+  config = mergeWithEnvironment(config || DEFAULT_CONFIG);
+
+  return config;
+}
+
+/**
+ * Merge configuration with environment variables
+ * Supports:
+ * - MCP_SERVERS_<NAME>_COMMAND: Command for server
+ * - MCP_SERVERS_<NAME>_ARGS: Comma-separated args
+ * - MCP_SERVERS_<NAME>_TRANSPORT: Transport type
+ * - MCP_SERVERS_<NAME>_URL: URL for HTTP/WebSocket transports
+ * - MCP_SERVERS_<NAME>_ENABLED: Enable/disable server
+ */
+function mergeWithEnvironment(config) {
+  const serverPattern = /^MCP_SERVERS_([A-Z0-9_]+)_(.+)$/;
+
+  for (const [key, value] of Object.entries(process.env)) {
+    const match = key.match(serverPattern);
+    if (match) {
+      const [, serverName, property] = match;
+      const normalizedName = serverName.toLowerCase().replace(/_/g, '-');
+
+      if (!config.mcpServers) {
+        config.mcpServers = {};
+      }
+
+      if (!config.mcpServers[normalizedName]) {
+        config.mcpServers[normalizedName] = {};
+      }
+
+      switch (property) {
+        case 'COMMAND':
+          config.mcpServers[normalizedName].command = value;
+          break;
+        case 'ARGS':
+          config.mcpServers[normalizedName].args = value.split(',').map(arg => arg.trim());
+          break;
+        case 'TRANSPORT':
+          config.mcpServers[normalizedName].transport = value.toLowerCase();
+          break;
+        case 'URL':
+          config.mcpServers[normalizedName].url = value;
+          break;
+        case 'ENABLED':
+          config.mcpServers[normalizedName].enabled = value === 'true' || value === '1';
+          break;
+        case 'ENV':
+          // Support custom environment variables for the server
+          try {
+            config.mcpServers[normalizedName].env = JSON.parse(value);
+          } catch {
+            config.mcpServers[normalizedName].env = { [property]: value };
+          }
+          break;
+      }
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Parse MCP server configuration to extract enabled servers
+ * @param {Object} config - Full MCP configuration
+ * @returns {Array} Array of server configurations ready for connection
+ */
+export function parseEnabledServers(config) {
+  const servers = [];
+
+  if (!config || !config.mcpServers) {
+    return servers;
+  }
+
+  for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+    // Skip disabled servers
+    if (serverConfig.enabled === false) {
+      continue;
+    }
+
+    const server = {
+      name,
+      ...serverConfig
+    };
+
+    // Set default transport if not specified
+    if (!server.transport) {
+      if (server.url) {
+        // Infer transport from URL
+        if (server.url.startsWith('ws://') || server.url.startsWith('wss://')) {
+          server.transport = 'websocket';
+        } else if (server.url.includes('/sse')) {
+          server.transport = 'sse';
+        } else {
+          server.transport = 'http';
+        }
+      } else {
+        server.transport = 'stdio';
+      }
+    }
+
+    // Validate required fields based on transport
+    if (server.transport === 'stdio') {
+      if (!server.command) {
+        console.error(`[MCP] Server ${name} missing required 'command' for stdio transport`);
+        continue;
+      }
+    } else if (['websocket', 'sse', 'http'].includes(server.transport)) {
+      if (!server.url) {
+        console.error(`[MCP] Server ${name} missing required 'url' for ${server.transport} transport`);
+        continue;
+      }
+    }
+
+    servers.push(server);
+  }
+
+  return servers;
+}
+
+/**
+ * Create a sample MCP configuration file
+ */
+export function createSampleConfig() {
+  return {
+    mcpServers: {
+      'probe': {
+        command: 'npx',
+        args: ['-y', '@probelabs/probe@latest', 'mcp'],
+        transport: 'stdio',
+        enabled: true,
+        description: 'Probe code search MCP server'
+      },
+      'filesystem': {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-filesystem', process.cwd()],
+        transport: 'stdio',
+        enabled: false,
+        description: 'Filesystem operations MCP server'
+      },
+      'github': {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-github'],
+        transport: 'stdio',
+        enabled: false,
+        description: 'GitHub API MCP server',
+        env: {
+          GITHUB_TOKEN: 'your-github-token'
+        }
+      },
+      'postgres': {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-postgres'],
+        transport: 'stdio',
+        enabled: false,
+        description: 'PostgreSQL database MCP server',
+        env: {
+          DATABASE_URL: 'postgresql://user:pass@localhost/db'
+        }
+      },
+      'custom-http': {
+        url: 'http://localhost:3000/mcp',
+        transport: 'http',
+        enabled: false,
+        description: 'Custom HTTP MCP server'
+      },
+      'custom-websocket': {
+        url: 'ws://localhost:8080',
+        transport: 'websocket',
+        enabled: false,
+        description: 'Custom WebSocket MCP server'
+      }
+    },
+    // Global settings
+    settings: {
+      timeout: 30000,
+      retryCount: 3,
+      debug: false
+    }
+  };
+}
+
+/**
+ * Save configuration to file
+ * @param {Object} config - Configuration to save
+ * @param {string} path - Path to save to
+ */
+export function saveConfig(config, path) {
+  const dir = dirname(path);
+
+  // Create directory if it doesn't exist
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  writeFileSync(path, JSON.stringify(config, null, 2), 'utf8');
+  console.log(`[MCP] Configuration saved to: ${path}`);
+}
+
+export default {
+  loadMCPConfiguration,
+  loadMCPConfigurationFromPath,
+  parseEnabledServers,
+  createSampleConfig,
+  saveConfig
+};

package/build/agent/mcp/index.js

@@ -0,0 +1,64 @@
+/**
+ * MCP (Model Context Protocol) integration for ProbeAgent
+ *
+ * This module provides:
+ * - MCP client management for connecting to MCP servers
+ * - XML/JSON hybrid tool interface
+ * - Configuration management
+ */
+
+// Re-export main classes and functions
+export { MCPClientManager, createMCPManager, createTransport } from './client.js';
+export {
+  loadMCPConfiguration,
+  loadMCPConfigurationFromPath,
+  parseEnabledServers,
+  createSampleConfig,
+  saveConfig
+} from './config.js';
+export {
+  MCPXmlBridge,
+  mcpToolToXmlDefinition,
+  parseXmlMcpToolCall,
+  parseHybridXmlToolCall,
+  createHybridSystemMessage
+} from './xmlBridge.js';
+
+// Import for default export
+import { MCPClientManager, createMCPManager, createTransport } from './client.js';
+import {
+  loadMCPConfiguration,
+  loadMCPConfigurationFromPath,
+  parseEnabledServers,
+  createSampleConfig,
+  saveConfig
+} from './config.js';
+import {
+  MCPXmlBridge,
+  mcpToolToXmlDefinition,
+  parseXmlMcpToolCall,
+  parseHybridXmlToolCall,
+  createHybridSystemMessage
+} from './xmlBridge.js';
+
+// Default export for convenience
+export default {
+  // Client
+  MCPClientManager,
+  createMCPManager,
+  createTransport,
+
+  // Config
+  loadMCPConfiguration,
+  loadMCPConfigurationFromPath,
+  parseEnabledServers,
+  createSampleConfig,
+  saveConfig,
+
+  // XML Bridge
+  MCPXmlBridge,
+  mcpToolToXmlDefinition,
+  parseXmlMcpToolCall,
+  parseHybridXmlToolCall,
+  createHybridSystemMessage
+};