@probelabs/probe 0.6.0-rc207 → 0.6.0-rc208

package/build/agent/index.js

@@ -10601,9 +10601,11 @@ var init_bashPermissions = __esm({
        * @param {boolean} [config.disableDefaultAllow] - Disable default allow list
        * @param {boolean} [config.disableDefaultDeny] - Disable default deny list
        * @param {boolean} [config.debug] - Enable debug logging
+       * @param {Object} [config.tracer] - Optional tracer for telemetry
        */
       constructor(config = {}) {
         this.debug = config.debug || false;
+        this.tracer = config.tracer || null;
         this.allowPatterns = [];
         if (!config.disableDefaultAllow) {
           this.allowPatterns.push(...DEFAULT_ALLOW_PATTERNS);
@@ -10633,6 +10635,24 @@ var init_bashPermissions = __esm({
         if (this.debug) {
           console.log(`[BashPermissions] Total patterns - Allow: ${this.allowPatterns.length}, Deny: ${this.denyPatterns.length}`);
         }
+        this.recordBashEvent("permissions.initialized", {
+          allowPatternCount: this.allowPatterns.length,
+          denyPatternCount: this.denyPatterns.length,
+          hasCustomAllowPatterns: !!(config.allow && config.allow.length > 0),
+          hasCustomDenyPatterns: !!(config.deny && config.deny.length > 0),
+          disableDefaultAllow: !!config.disableDefaultAllow,
+          disableDefaultDeny: !!config.disableDefaultDeny
+        });
+      }
+      /**
+       * Record a bash telemetry event if tracer is available
+       * @param {string} eventType - Event type (e.g., 'permission.checked', 'permission.denied')
+       * @param {Object} data - Event data
+       */
+      recordBashEvent(eventType, data = {}) {
+        if (this.tracer && typeof this.tracer.recordBashEvent === "function") {
+          this.tracer.recordBashEvent(eventType, data);
+        }
       }
       /**
        * Check if a simple command is allowed (complex commands allowed if they match patterns)
@@ -10641,11 +10661,17 @@ var init_bashPermissions = __esm({
        */
       check(command) {
         if (!command || typeof command !== "string") {
-          return {
+          const result2 = {
             allowed: false,
             reason: "Invalid or empty command",
             command
           };
+          this.recordBashEvent("permission.denied", {
+            command: String(command),
+            reason: result2.reason,
+            isComplex: false
+          });
+          return result2;
         }
         const commandIsComplex = isComplexCommand(command);
         if (commandIsComplex) {
@@ -10653,18 +10679,31 @@ var init_bashPermissions = __esm({
         }
         const parsed = parseCommand(command);
         if (parsed.error) {
-          return {
+          const result2 = {
             allowed: false,
             reason: parsed.error,
             command
           };
+          this.recordBashEvent("permission.denied", {
+            command,
+            reason: result2.reason,
+            isComplex: false,
+            parseError: true
+          });
+          return result2;
         }
         if (!parsed.command) {
-          return {
+          const result2 = {
             allowed: false,
             reason: "No valid command found",
             command
           };
+          this.recordBashEvent("permission.denied", {
+            command,
+            reason: result2.reason,
+            isComplex: false
+          });
+          return result2;
         }
         if (this.debug) {
           console.log(`[BashPermissions] Checking simple command: "${command}"`);
@@ -10672,22 +10711,37 @@ var init_bashPermissions = __esm({
         }
         if (matchesAnyPattern(parsed, this.denyPatterns)) {
           const matchedPatterns = this.denyPatterns.filter((pattern) => matchesPattern(parsed, pattern));
-          return {
+          const result2 = {
             allowed: false,
             reason: `Command matches deny pattern: ${matchedPatterns[0]}`,
             command,
             parsed,
             matchedPatterns
           };
+          this.recordBashEvent("permission.denied", {
+            command,
+            parsedCommand: parsed.command,
+            reason: "matches_deny_pattern",
+            matchedPattern: matchedPatterns[0],
+            isComplex: false
+          });
+          return result2;
         }
         if (this.allowPatterns.length > 0) {
           if (!matchesAnyPattern(parsed, this.allowPatterns)) {
-            return {
+            const result2 = {
               allowed: false,
               reason: "Command not in allow list",
               command,
               parsed
             };
+            this.recordBashEvent("permission.denied", {
+              command,
+              parsedCommand: parsed.command,
+              reason: "not_in_allow_list",
+              isComplex: false
+            });
+            return result2;
           }
         }
         const result = {
@@ -10699,6 +10753,11 @@ var init_bashPermissions = __esm({
         if (this.debug) {
           console.log(`[BashPermissions] ALLOWED - command passed all checks`);
         }
+        this.recordBashEvent("permission.allowed", {
+          command,
+          parsedCommand: parsed.command,
+          isComplex: false
+        });
         return result;
       }
       /**
@@ -10722,13 +10781,20 @@ var init_bashPermissions = __esm({
             if (this.debug) {
               console.log(`[BashPermissions] DENIED - matches complex deny pattern: ${pattern}`);
             }
-            return {
+            const result = {
               allowed: false,
               reason: `Command matches deny pattern: ${pattern}`,
               command,
               isComplex: true,
               matchedPatterns: [pattern]
             };
+            this.recordBashEvent("permission.denied", {
+              command,
+              reason: "matches_deny_pattern",
+              matchedPattern: pattern,
+              isComplex: true
+            });
+            return result;
           }
         }
         for (const pattern of complexAllowPatterns) {
@@ -10736,17 +10802,28 @@ var init_bashPermissions = __esm({
             if (this.debug) {
               console.log(`[BashPermissions] ALLOWED - matches complex allow pattern: ${pattern}`);
             }
-            return {
+            const result = {
               allowed: true,
               command,
               isComplex: true,
               matchedPattern: pattern
             };
+            this.recordBashEvent("permission.allowed", {
+              command,
+              matchedPattern: pattern,
+              isComplex: true
+            });
+            return result;
           }
         }
         if (this.debug) {
           console.log(`[BashPermissions] DENIED - no matching complex pattern found`);
         }
+        this.recordBashEvent("permission.denied", {
+          command,
+          reason: "no_matching_complex_pattern",
+          isComplex: true
+        });
         return {
           allowed: false,
           reason: 'Complex shell commands require explicit allow patterns (e.g., "cd * && git *")',
@@ -11044,14 +11121,16 @@ var init_bash = __esm({
         bashConfig = {},
         debug = false,
         cwd,
-        allowedFolders = []
+        allowedFolders = [],
+        tracer = null
       } = options;
       const permissionChecker = new BashPermissionChecker({
         allow: bashConfig.allow,
         deny: bashConfig.deny,
         disableDefaultAllow: bashConfig.disableDefaultAllow,
         disableDefaultDeny: bashConfig.disableDefaultDeny,
-        debug
+        debug,
+        tracer
       });
       const getDefaultWorkingDirectory = () => {
         if (bashConfig.workingDirectory) {
@@ -11681,6 +11760,28 @@ var init_simpleTelemetry = __esm({
           ...data
         });
       }
+      /**
+       * Record MCP (Model Context Protocol) events
+       * Tracks server connections, tool discovery, method filtering, and tool execution
+       */
+      recordMcpEvent(eventType, data = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`mcp.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data
+        });
+      }
+      /**
+       * Record bash tool events
+       * Tracks command permission checks, allowed/denied commands, and execution
+       */
+      recordBashEvent(eventType, data = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`bash.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data
+        });
+      }
       setAttributes(attributes) {
         if (this.telemetry && this.telemetry.enableConsole) {
           console.log("[Attributes]", attributes);
@@ -57907,6 +58008,47 @@ function validateTimeout(value) {
   if (!Number.isFinite(num) || num < 0) return void 0;
   return Math.min(num, MAX_TIMEOUT);
 }
+function validateMethodFilter(serverConfig, serverName = "unknown") {
+  const result = { allowedMethods: null, blockedMethods: null };
+  const debug = process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1";
+  if (serverConfig.allowedMethods && serverConfig.blockedMethods) {
+    console.error(`[MCP WARN] Server '${serverName}' has both allowedMethods and blockedMethods - using allowedMethods only`);
+  }
+  if (serverConfig.allowedMethods) {
+    if (!Array.isArray(serverConfig.allowedMethods)) {
+      console.error(`[MCP WARN] Server '${serverName}' allowedMethods must be an array, ignoring`);
+    } else {
+      const validMethods = serverConfig.allowedMethods.filter((m) => typeof m === "string" && m.length > 0);
+      if (validMethods.length !== serverConfig.allowedMethods.length) {
+        console.error(`[MCP WARN] Server '${serverName}' allowedMethods contains non-string values, skipping those`);
+      }
+      if (validMethods.length > 0) {
+        result.allowedMethods = validMethods;
+        if (debug) {
+          console.error(`[MCP DEBUG] Server '${serverName}' allowedMethods: ${validMethods.join(", ")}`);
+        }
+      }
+    }
+    return result;
+  }
+  if (serverConfig.blockedMethods) {
+    if (!Array.isArray(serverConfig.blockedMethods)) {
+      console.error(`[MCP WARN] Server '${serverName}' blockedMethods must be an array, ignoring`);
+    } else {
+      const validMethods = serverConfig.blockedMethods.filter((m) => typeof m === "string" && m.length > 0);
+      if (validMethods.length !== serverConfig.blockedMethods.length) {
+        console.error(`[MCP WARN] Server '${serverName}' blockedMethods contains non-string values, skipping those`);
+      }
+      if (validMethods.length > 0) {
+        result.blockedMethods = validMethods;
+        if (debug) {
+          console.error(`[MCP DEBUG] Server '${serverName}' blockedMethods: ${validMethods.join(", ")}`);
+        }
+      }
+    }
+  }
+  return result;
+}
 function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
@@ -58000,6 +58142,12 @@ function mergeWithEnvironment(config) {
             console.error(`[MCP WARN] Invalid timeout value for ${normalizedName}: ${value}`);
           }
           break;
+        case "ALLOWLIST":
+          config.mcpServers[normalizedName].allowedMethods = value.split(",").map((m) => m.trim()).filter(Boolean);
+          break;
+        case "BLOCKLIST":
+          config.mcpServers[normalizedName].blockedMethods = value.split(",").map((m) => m.trim()).filter(Boolean);
+          break;
       }
     }
   }
@@ -58050,6 +58198,9 @@ function parseEnabledServers(config) {
       }
       server.timeout = validatedTimeout;
     }
+    const methodFilter = validateMethodFilter(serverConfig, name);
+    server.allowedMethods = methodFilter.allowedMethods;
+    server.blockedMethods = methodFilter.blockedMethods;
     servers.push(server);
   }
   return servers;
@@ -58087,6 +58238,22 @@ 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";
+function isMethodAllowed(methodName, allowedMethods, blockedMethods) {
+  const matchesPattern2 = (name, pattern) => {
+    if (!pattern.includes("*")) {
+      return name === pattern;
+    }
+    const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${regexPattern}$`).test(name);
+  };
+  if (allowedMethods && allowedMethods.length > 0) {
+    return allowedMethods.some((pattern) => matchesPattern2(methodName, pattern));
+  }
+  if (blockedMethods && blockedMethods.length > 0) {
+    return !blockedMethods.some((pattern) => matchesPattern2(methodName, pattern));
+  }
+  return true;
+}
 function createTransport(serverConfig) {
   const { transport, command, args, url, env } = serverConfig;
   switch (transport) {
@@ -58167,6 +58334,17 @@ var init_client = __esm({
         this.tools = /* @__PURE__ */ new Map();
         this.debug = options.debug || process.env.DEBUG_MCP === "1";
         this.config = null;
+        this.tracer = options.tracer || null;
+      }
+      /**
+       * Record an MCP telemetry event if tracer is available
+       * @param {string} eventType - Event type (e.g., 'server.connect', 'tool.discovered')
+       * @param {Object} data - Event data
+       */
+      recordMcpEvent(eventType, data = {}) {
+        if (this.tracer && typeof this.tracer.recordMcpEvent === "function") {
+          this.tracer.recordMcpEvent(eventType, data);
+        }
       }
       /**
        * Initialize MCP clients from configuration
@@ -58175,10 +58353,20 @@ var init_client = __esm({
       async initialize(config = null) {
         this.config = config || loadMCPConfiguration();
         const servers = parseEnabledServers(this.config);
+        this.recordMcpEvent("initialization.started", {
+          serverCount: servers.length,
+          serverNames: servers.map((s) => s.name)
+        });
         console.error(`[MCP INFO] Found ${servers.length} enabled MCP server${servers.length !== 1 ? "s" : ""}`);
         if (servers.length === 0) {
           console.error("[MCP INFO] No MCP servers configured or enabled");
           console.error("[MCP INFO] 0 MCP tools available");
+          this.recordMcpEvent("initialization.completed", {
+            connected: 0,
+            total: 0,
+            toolCount: 0,
+            tools: []
+          });
           return {
             connected: 0,
             total: 0,
@@ -58215,10 +58403,17 @@ var init_client = __esm({
             console.error(`[MCP DEBUG]   - ${toolName}`);
           });
         }
+        const toolNames = Array.from(this.tools.keys());
+        this.recordMcpEvent("initialization.completed", {
+          connected: connectedCount,
+          total: servers.length,
+          toolCount: this.tools.size,
+          tools: toolNames
+        });
         return {
           connected: connectedCount,
           total: servers.length,
-          tools: Array.from(this.tools.keys())
+          tools: toolNames
         };
       }
       /**
@@ -58227,6 +58422,12 @@ var init_client = __esm({
        */
       async connectToServer(serverConfig) {
         const { name } = serverConfig;
+        this.recordMcpEvent("server.connecting", {
+          serverName: name,
+          transport: serverConfig.transport,
+          hasAllowedMethods: !!(serverConfig.allowedMethods && serverConfig.allowedMethods.length > 0),
+          hasBlockedMethods: !!(serverConfig.blockedMethods && serverConfig.blockedMethods.length > 0)
+        });
         try {
           if (this.debug) {
             console.error(`[MCP DEBUG] Connecting to ${name} via ${serverConfig.transport}...`);
@@ -58248,27 +58449,92 @@ var init_client = __esm({
             config: serverConfig
           });
           const toolsResponse = await client.listTools();
-          const toolCount = toolsResponse?.tools?.length || 0;
+          const totalToolCount = toolsResponse?.tools?.length || 0;
+          let registeredCount = 0;
+          let filteredCount = 0;
+          const registeredTools = [];
+          const filteredTools = [];
           if (toolsResponse && toolsResponse.tools) {
+            const { allowedMethods, blockedMethods } = serverConfig;
+            const allToolNames = toolsResponse.tools.map((t) => t.name);
+            this.recordMcpEvent("tools.discovered", {
+              serverName: name,
+              toolCount: totalToolCount,
+              tools: allToolNames
+            });
             for (const tool4 of toolsResponse.tools) {
+              if (!isMethodAllowed(tool4.name, allowedMethods, blockedMethods)) {
+                filteredCount++;
+                filteredTools.push(tool4.name);
+                if (this.debug) {
+                  console.error(`[MCP DEBUG]     Filtered out tool: ${tool4.name} (not allowed by method filter)`);
+                }
+                continue;
+              }
               const qualifiedName = `${name}_${tool4.name}`;
               this.tools.set(qualifiedName, {
                 ...tool4,
                 serverName: name,
                 originalName: tool4.name
               });
+              registeredCount++;
+              registeredTools.push(qualifiedName);
               if (this.debug) {
                 console.error(`[MCP DEBUG]     Registered tool: ${qualifiedName}`);
               }
             }
+            if (filteredCount > 0) {
+              this.recordMcpEvent("tools.filtered", {
+                serverName: name,
+                filteredCount,
+                filteredTools,
+                allowedMethods: allowedMethods || [],
+                blockedMethods: blockedMethods || []
+              });
+            }
+            if (allowedMethods && allowedMethods.length > 0) {
+              const unmatchedPatterns = allowedMethods.filter((pattern) => {
+                return !allToolNames.some((toolName) => isMethodAllowed(toolName, [pattern], null));
+              });
+              if (unmatchedPatterns.length > 0) {
+                console.error(`[MCP WARN] Server '${name}': The following allowedMethods patterns did not match any tools: ${unmatchedPatterns.join(", ")}`);
+                console.error(`[MCP WARN] Available methods from '${name}': ${allToolNames.join(", ")}`);
+              }
+            }
+            if (blockedMethods && blockedMethods.length > 0) {
+              const unmatchedPatterns = blockedMethods.filter((pattern) => {
+                return !allToolNames.some((toolName) => !isMethodAllowed(toolName, null, [pattern]));
+              });
+              if (unmatchedPatterns.length > 0) {
+                console.error(`[MCP WARN] Server '${name}': The following blockedMethods patterns did not match any tools: ${unmatchedPatterns.join(", ")}`);
+                console.error(`[MCP WARN] Available methods from '${name}': ${allToolNames.join(", ")}`);
+              }
+            }
           }
-          console.error(`[MCP INFO] Connected to ${name}: ${toolCount} tool${toolCount !== 1 ? "s" : ""} loaded`);
+          if (filteredCount > 0) {
+            console.error(`[MCP INFO] Connected to ${name}: ${registeredCount} tool${registeredCount !== 1 ? "s" : ""} loaded (${filteredCount} filtered out)`);
+          } else {
+            console.error(`[MCP INFO] Connected to ${name}: ${registeredCount} tool${registeredCount !== 1 ? "s" : ""} loaded`);
+          }
+          this.recordMcpEvent("server.connected", {
+            serverName: name,
+            transport: serverConfig.transport,
+            totalToolCount,
+            registeredCount,
+            filteredCount,
+            registeredTools
+          });
           return true;
         } catch (error) {
           console.error(`[MCP ERROR] Error connecting to ${name}:`, error.message);
           if (this.debug) {
             console.error(`[MCP DEBUG] Full error details:`, error);
           }
+          this.recordMcpEvent("server.connection_failed", {
+            serverName: name,
+            transport: serverConfig.transport,
+            error: error.message
+          });
           return false;
         }
       }
@@ -58280,12 +58546,27 @@ var init_client = __esm({
       async callTool(toolName, args) {
         const tool4 = this.tools.get(toolName);
         if (!tool4) {
+          this.recordMcpEvent("tool.call_failed", {
+            toolName,
+            error: "Unknown tool"
+          });
           throw new Error(`Unknown tool: ${toolName}`);
         }
         const clientInfo = this.clients.get(tool4.serverName);
         if (!clientInfo) {
+          this.recordMcpEvent("tool.call_failed", {
+            toolName,
+            serverName: tool4.serverName,
+            error: "Server not connected"
+          });
           throw new Error(`Server ${tool4.serverName} not connected`);
         }
+        const startTime = Date.now();
+        this.recordMcpEvent("tool.call_started", {
+          toolName,
+          serverName: tool4.serverName,
+          originalToolName: tool4.originalName
+        });
         try {
           if (this.debug) {
             console.error(`[MCP DEBUG] Calling ${toolName} with args:`, JSON.stringify(args, null, 2));
@@ -58305,15 +58586,31 @@ var init_client = __esm({
             }),
             timeoutPromise
           ]);
+          const durationMs = Date.now() - startTime;
           if (this.debug) {
             console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
           }
+          this.recordMcpEvent("tool.call_completed", {
+            toolName,
+            serverName: tool4.serverName,
+            originalToolName: tool4.originalName,
+            durationMs
+          });
           return result;
         } catch (error) {
+          const durationMs = Date.now() - startTime;
           console.error(`[MCP ERROR] Error calling tool ${toolName}:`, error.message);
           if (this.debug) {
             console.error(`[MCP DEBUG] Full error details:`, error);
           }
+          this.recordMcpEvent("tool.call_failed", {
+            toolName,
+            serverName: tool4.serverName,
+            originalToolName: tool4.originalName,
+            error: error.message,
+            durationMs,
+            isTimeout: error.message.includes("timeout")
+          });
           throw error;
         }
       }
@@ -58358,12 +58655,17 @@ var init_client = __esm({
        */
       async disconnect() {
         const disconnectPromises = [];
+        const serverNames = Array.from(this.clients.keys());
         if (this.clients.size === 0) {
           if (this.debug) {
             console.error("[MCP DEBUG] No MCP clients to disconnect");
           }
           return;
         }
+        this.recordMcpEvent("disconnection.started", {
+          serverCount: this.clients.size,
+          serverNames
+        });
         if (this.debug) {
           console.error(`[MCP DEBUG] Disconnecting from ${this.clients.size} MCP server${this.clients.size !== 1 ? "s" : ""}...`);
         }
@@ -58373,14 +58675,25 @@ var init_client = __esm({
               if (this.debug) {
                 console.error(`[MCP DEBUG] Disconnected from ${name}`);
               }
+              this.recordMcpEvent("server.disconnected", {
+                serverName: name
+              });
             }).catch((error) => {
               console.error(`[MCP ERROR] Error disconnecting from ${name}:`, error.message);
+              this.recordMcpEvent("server.disconnect_failed", {
+                serverName: name,
+                error: error.message
+              });
             })
           );
         }
         await Promise.all(disconnectPromises);
         this.clients.clear();
         this.tools.clear();
+        this.recordMcpEvent("disconnection.completed", {
+          serverCount: serverNames.length,
+          serverNames
+        });
         if (this.debug) {
           console.error("[MCP DEBUG] All MCP connections closed");
         }
@@ -58524,6 +58837,7 @@ var init_xmlBridge = __esm({
     MCPXmlBridge = class {
       constructor(options = {}) {
         this.debug = options.debug || false;
+        this.tracer = options.tracer || null;
         this.mcpTools = {};
         this.mcpManager = null;
         this.xmlDefinitions = {};
@@ -58566,7 +58880,7 @@ var init_xmlBridge = __esm({
           if (this.debug) {
             console.error("[MCP DEBUG] Initializing MCP client manager...");
           }
-          this.mcpManager = new MCPClientManager({ debug: this.debug });
+          this.mcpManager = new MCPClientManager({ debug: this.debug, tracer: this.tracer });
           const result = await this.mcpManager.initialize(mcpConfigs);
           const vercelTools = this.mcpManager.getVercelTools();
           this.mcpTools = vercelTools;
@@ -58590,11 +58904,15 @@ var init_xmlBridge = __esm({
         }
       }
       /**
-       * Get all XML tool definitions for inclusion in system prompt
+       * Get XML tool definitions for inclusion in system prompt
+       * @param {Array<string>|null} filterToolNames - Optional list of tool names to include (if null, include all)
        * @returns {string} Combined XML tool definitions
        */
-      getXmlToolDefinitions() {
-        return Object.values(this.xmlDefinitions).join("\n\n");
+      getXmlToolDefinitions(filterToolNames = null) {
+        if (filterToolNames === null) {
+          return Object.values(this.xmlDefinitions).join("\n\n");
+        }
+        return Object.entries(this.xmlDefinitions).filter(([name]) => filterToolNames.includes(name)).map(([, def]) => def).join("\n\n");
       }
       /**
        * Get list of MCP tool names