feat(satellite): implement disabled tool management and filtering

Author: Lasim

services/satellite/src/core/mcp-server-wrapper.ts

@@ -260,10 +260,64 @@ export class McpServerWrapper {
       arguments: toolArguments
     }, `Tool arguments for ${toolPath}`);
 
+    // Check if tool exists and get cached tool info for disabled check
+    const cachedTool = this.toolDiscoveryManager.getTool(namespacedToolName);
+    if (!cachedTool) {
+      const allTools = this.toolDiscoveryManager.getAllTools();
+      throw new Error(`Tool not found: ${namespacedToolName}. Available tools: ${allTools.map(t => t.namespacedName).join(', ')}`);
+    }
+
+    // Check if tool is disabled
+    if (this.dynamicConfigManager) {
+      const config = this.dynamicConfigManager.getMcpServerConfig(cachedTool.serverName);
+      if (config?.installation_id) {
+        const isDisabled = this.toolDiscoveryManager.isToolDisabled(
+          config.installation_id,
+          cachedTool.originalName
+        );
+
+        if (isDisabled) {
+          this.logger.warn({
+            operation: 'execute_mcp_tool_disabled',
+            tool_path: toolPath,
+            installation_id: config.installation_id,
+            tool_name: cachedTool.originalName
+          }, `Tool execution blocked - tool is disabled: ${toolPath}`);
+
+          return this.createDisabledToolResponse(toolPath);
+        }
+      }
+    }
+
     // Route to executeToolCall with namespaced format
     return await this.executeToolCall(namespacedToolName, toolArguments);
   }
 
+  /**
+   * Create LLM-friendly error response for disabled tools
+   */
+  private createDisabledToolResponse(toolPath: string): any {
+    const message = [
+      `Tool '${toolPath}' has been disabled by the team administrator.`,
+      '',
+      'This tool is currently unavailable and cannot be executed.',
+      '',
+      'Recommended actions:',
+      '1. Use discover_mcp_tools to find alternative tools that can accomplish your task',
+      '2. Contact your team administrator if you need this tool enabled',
+      '',
+      `Disabled tool: ${toolPath}`
+    ].join('\n');
+
+    return {
+      content: [{
+        type: 'text',
+        text: message
+      }],
+      isError: true
+    };
+  }
+
   /**
    * Check for dormant stdio processes and respawn them before tool discovery
    */

services/satellite/src/server.ts

@@ -265,10 +265,11 @@ export async function createServer() {
 
   // Initialize Tool Search Service for hierarchical router (discover_mcp_tools meta-tool)
   const toolSearchService = new ToolSearchService(toolDiscoveryManager, server.log);
-  
+  toolSearchService.setConfigManager(dynamicConfigManager);
+
   server.log.info({
     operation: 'tool_search_service_initialized'
-  }, 'Tool Search Service initialized for hierarchical MCP router');
+  }, 'Tool Search Service initialized for hierarchical MCP router (disabled tool filtering enabled)');
 
   // Initialize MCP Server Wrapper with official SDK (replaces custom transport handlers)
   const mcpServerWrapper = new McpServerWrapper(server.log);
@@ -424,10 +425,14 @@ export async function createServer() {
     stdioToolDiscoveryManager
   );
 
+  // Set UnifiedToolDiscoveryManager for disabled tools tracking
+  commandProcessor.setUnifiedToolDiscoveryManager(toolDiscoveryManager);
+
   server.log.info({
     operation: 'command_processor_initialized',
-    stdio_support: true
-  }, 'Command Processor initialized with stdio process management support');
+    stdio_support: true,
+    disabled_tools_support: true
+  }, 'Command Processor initialized with stdio process management and disabled tools support');
 
   // Initialize Command Polling Service (will be started after registration)
   let commandPollingService: CommandPollingService | undefined;

services/satellite/src/services/command-processor.ts

@@ -4,6 +4,7 @@ import { DynamicConfigManager } from './dynamic-config-manager';
 import { ProcessManager } from '../process/manager';
 import { RuntimeState } from '../process/runtime-state';
 import { StdioToolDiscoveryManager } from './stdio-tool-discovery-manager';
+import { UnifiedToolDiscoveryManager } from './unified-tool-discovery-manager';
 import { MCPServerConfig } from '../process/types';
 import { maskUrlForLogging } from '../utils/log-masker';
 
@@ -24,6 +25,7 @@ export class CommandProcessor {
   private processManager: ProcessManager | null;
   private runtimeState: RuntimeState | null;
   private stdioDiscoveryManager: StdioToolDiscoveryManager | null;
+  private unifiedToolDiscoveryManager: UnifiedToolDiscoveryManager | null = null;
   private processes: Map<string, ProcessInfo> = new Map();
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   private onConfigurationUpdate?: (config: any) => Promise<void>;
@@ -50,6 +52,13 @@ export class CommandProcessor {
     this.onConfigurationUpdate = handler;
   }
 
+  /**
+   * Set unified tool discovery manager for disabled tools tracking
+   */
+  setUnifiedToolDiscoveryManager(manager: UnifiedToolDiscoveryManager): void {
+    this.unifiedToolDiscoveryManager = manager;
+  }
+
   /**
    * Resolve installation_id or server_name to actual server name
    */
@@ -159,9 +168,17 @@ export class CommandProcessor {
   }
 
   /**
-   * Handle configure command - update MCP server configuration
+   * Handle configure command - update MCP server configuration or handle specific actions
    */
   private async handleConfigureCommand(command: SatelliteCommand): Promise<CommandResult> {
+    const payload = command.payload;
+
+    // Check if this is an update_tool_status action
+    if (payload.action === 'update_tool_status') {
+      return await this.handleUpdateToolStatus(command);
+    }
+
+    // Default behavior: trigger configuration refresh
     this.logger.info({
       operation: 'command_configure',
       command_id: command.id
@@ -174,7 +191,7 @@ export class CommandProcessor {
           operation: 'command_configure_trigger',
           command_id: command.id
         }, 'Triggering configuration update from backend');
-        
+
         // This will fetch fresh config from backend and update all services
         await this.onConfigurationUpdate({});
       } else {
@@ -185,7 +202,7 @@ export class CommandProcessor {
       }
 
       const currentStats = this.configManager.getStats();
-      
+
       return {
         command_id: command.id,
         status: 'completed',
@@ -198,17 +215,115 @@ export class CommandProcessor {
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      
+
       this.logger.error({
         operation: 'command_configure_failed',
         command_id: command.id,
         error: errorMessage
       }, `Configure command failed: ${errorMessage}`);
-      
+
       throw error; // Re-throw to be handled by main command processor
     }
   }
 
+  /**
+   * Handle update_tool_status action - enable/disable a specific tool
+   */
+  private async handleUpdateToolStatus(command: SatelliteCommand): Promise<CommandResult> {
+    const payload = command.payload;
+    const { installation_id, tool_name, is_disabled, team_id, server_slug } = payload;
+
+    this.logger.info({
+      operation: 'update_tool_status',
+      command_id: command.id,
+      installation_id,
+      tool_name,
+      is_disabled,
+      team_id,
+      server_slug
+    }, `Processing update_tool_status: ${is_disabled ? 'disabling' : 'enabling'} tool ${tool_name}`);
+
+    // Validate required fields
+    if (!installation_id || !tool_name || typeof is_disabled !== 'boolean') {
+      const errorMsg = 'Missing required fields: installation_id, tool_name, or is_disabled';
+      this.logger.error({
+        operation: 'update_tool_status_validation_failed',
+        command_id: command.id,
+        installation_id,
+        tool_name,
+        is_disabled
+      }, errorMsg);
+
+      return {
+        command_id: command.id,
+        status: 'failed',
+        error: errorMsg
+      };
+    }
+
+    // Check if UnifiedToolDiscoveryManager is available
+    if (!this.unifiedToolDiscoveryManager) {
+      const errorMsg = 'UnifiedToolDiscoveryManager not available - cannot update tool status';
+      this.logger.error({
+        operation: 'update_tool_status_no_manager',
+        command_id: command.id
+      }, errorMsg);
+
+      return {
+        command_id: command.id,
+        status: 'failed',
+        error: errorMsg
+      };
+    }
+
+    try {
+      // Update the tool status in the unified discovery manager
+      this.unifiedToolDiscoveryManager.setToolDisabled(
+        installation_id as string,
+        tool_name as string,
+        is_disabled as boolean
+      );
+
+      const action = is_disabled ? 'disabled' : 'enabled';
+      this.logger.info({
+        operation: 'update_tool_status_success',
+        command_id: command.id,
+        installation_id,
+        tool_name,
+        is_disabled,
+        team_id,
+        server_slug
+      }, `Tool ${tool_name} ${action} successfully`);
+
+      return {
+        command_id: command.id,
+        status: 'completed',
+        result: {
+          tool_name,
+          is_disabled,
+          message: `Tool ${action} successfully`
+        }
+      };
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      this.logger.error({
+        operation: 'update_tool_status_failed',
+        command_id: command.id,
+        installation_id,
+        tool_name,
+        error: errorMessage
+      }, `Failed to update tool status: ${errorMessage}`);
+
+      return {
+        command_id: command.id,
+        status: 'failed',
+        error: errorMessage
+      };
+    }
+  }
+
   /**
    * Handle spawn command - dispatches to HTTP or stdio handler based on transport_type
    */