Add tool discovery mode!

Only works with clients that support Sampling currently on VSCode.

Author: cameroncooke

.vscode/launch.json

@@ -4,8 +4,9 @@
     {
       "type": "node",
       "request": "attach",
-      "name": "Attach to MCP Server Dev",
+      "name": "Wait for MCP Server to Start",
       "port": 9999,
+      "address": "localhost",
       "restart": true,
       "skipFiles": [
         "<node_internals>/**"
@@ -17,7 +18,10 @@
       "cwd": "${workspaceFolder}",
       "sourceMapPathOverrides": {
         "/*": "${workspaceFolder}/src/*"
-      }
+      },
+      "timeout": 60000,
+      "localRoot": "${workspaceFolder}",
+      "remoteRoot": "${workspaceFolder}"
     },
     {
       "type": "node",

docs/TOOLS.md

@@ -198,13 +198,15 @@ XcodeBuildMCP supports two operating modes:
 #### Static Mode (Default)
 All tools are loaded and available immediately at startup. Provides complete access to the full toolset without restrictions. Set `XCODEBUILDMCP_DYNAMIC_TOOLS=false` or leave unset.
 
-#### Dynamic Mode  
-Only the `discover_tools` tool is available initially. AI agents can use `discover_tools` to analyze task descriptions and intelligently enable relevant workflow based tool-groups on-demand. Set `XCODEBUILDMCP_DYNAMIC_TOOLS=true` to enable.
+#### Dynamic Mode (Experimental)
+Only the `discover_tools` and `discover_projs` tools are available initially. AI agents can use `discover_tools` tool to provide a task description that the server will analyze and intelligently enable relevant workflow based tool-groups on-demand. Set `XCODEBUILDMCP_DYNAMIC_TOOLS=true` to enable.
 
 ## MCP Resources
 
 For clients that support MCP resources, XcodeBuildMCP provides efficient URI-based data access:
 
 | Resource URI | Description | Mirrors Tool |
 |--------------|-------------|---------------|
-| `xcodebuildmcp://simulators` | Available iOS simulators with UUIDs and states | `list_sims` |
+| `xcodebuildmcp://simulators` | Available iOS simulators with UUIDs and states | `list_sims` |
+| `xcodebuildmcp://devices` | Available physical Apple devices with UUIDs, names, and connection status | `list_devices` |
+| `xcodebuildmcp://environment` | System diagnostics and environment validation | `diagnostic` |

package.json

@@ -58,7 +58,7 @@
     "url": "https://github.com/cameroncooke/XcodeBuildMCP/issues"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.6.1",
+    "@modelcontextprotocol/sdk": "github:cameroncooke/typescript-sdk#main",
     "@sentry/cli": "^2.43.1",
     "@sentry/node": "^9.15.0",
     "reloaderoo": "^1.0.1",

src/core/dynamic-tools.ts

@@ -3,6 +3,9 @@ import { getDefaultCommandExecutor, CommandExecutor } from '../utils/command.js'
 import { WORKFLOW_LOADERS, WorkflowName, WORKFLOW_METADATA } from './generated-plugins.js';
 import { ToolResponse } from '../types/common.js';
 import { PluginMeta } from './plugin-types.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerAndTrackTools } from '../utils/tool-registry.js';
+import { ZodRawShape } from 'zod';
 
 // Track enabled workflows and their tools for replacement functionality
 const enabledWorkflows = new Set<string>();
@@ -14,40 +17,7 @@ type ToolHandler = (
   executor: CommandExecutor,
 ) => Promise<ToolResponse>;
 
-// Interface for the MCP server with the methods we need
-interface MCPServerInterface {
-  tool(
-    name: string,
-    description: string,
-    schema: unknown,
-    handler: (args: unknown) => Promise<unknown>,
-  ): void;
-  registerTool?(
-    name: string,
-    config: {
-      title?: string;
-      description: string;
-      inputSchema?: unknown;
-      outputSchema?: unknown;
-      annotations?: unknown;
-    },
-    callback: (args: unknown) => Promise<unknown>,
-  ): unknown;
-  registerTools?(
-    tools: Array<{
-      name: string;
-      config: {
-        title?: string;
-        description: string;
-        inputSchema?: unknown;
-        outputSchema?: unknown;
-        annotations?: unknown;
-      };
-      callback: (args: unknown) => Promise<unknown>;
-    }>,
-  ): unknown[];
-  notifyToolsChanged?: () => Promise<void>;
-}
+// Use the actual McpServer type from the SDK instead of a custom interface
 
 /**
  * Wrapper function to adapt MCP SDK handler calling convention to our dependency injection pattern
@@ -99,7 +69,7 @@ export function getEnabledWorkflows(): string[] {
  * @param additive - If true, add to existing workflows. If false (default), replace existing workflows
  */
 export async function enableWorkflows(
-  server: MCPServerInterface,
+  server: McpServer,
   workflowNames: string[],
   additive: boolean = false,
 ): Promise<void> {
@@ -134,17 +104,16 @@ export async function enableWorkflows(
 
       log('info', `Enabling ${toolKeys.length} tools from '${workflowName}' workflow`);
 
-      // Prepare tools for bulk registration
       const toolsToRegister: Array<{
         name: string;
         config: {
           title?: string;
-          description: string;
-          inputSchema?: unknown;
-          outputSchema?: unknown;
-          annotations?: unknown;
+          description?: string;
+          inputSchema?: ZodRawShape;
+          outputSchema?: ZodRawShape;
+          annotations?: Record<string, unknown>;
         };
-        callback: (args: unknown) => Promise<unknown>;
+        callback: (args: Record<string, unknown>) => Promise<ToolResponse>;
       }> = [];
 
       // Collect all tools from this workflow
@@ -156,7 +125,7 @@ export async function enableWorkflows(
             name: tool.name,
             config: {
               description: tool.description ?? '',
-              inputSchema: tool.schema,
+              inputSchema: tool.schema, // MCP SDK now handles complex types properly
             },
             callback: wrapHandlerWithExecutor(tool.handler as ToolHandler),
           });
@@ -169,46 +138,66 @@ export async function enableWorkflows(
         }
       }
 
-      // Use bulk registration if available, otherwise fall back to individual registration
-      if (typeof (server as any).registerTools === 'function') {
-        try {
-          log('info', `🚀 Enabling ${toolsToRegister.length} tools from '${workflowName}' workflow`);
-          const registeredTools = (server as any).registerTools(toolsToRegister);
+      // Use bulk registration with proper types - no runtime checking needed
+      try {
+        const availableTools = toolsToRegister.filter((tool) => {
+          // In testing/development, check for duplicate registrations
+          // The MCP SDK handles this internally, so this is just for logging
+          log('debug', `Preparing to register tool: ${tool.name}`);
+          return true;
+        });
+
+        if (availableTools.length > 0) {
+          log('info', `🚀 Enabling ${availableTools.length} tools from '${workflowName}' workflow`);
+
+          // Convert to proper tool registration format, adapting callback signature
+          const toolRegistrations = availableTools.map((tool) => ({
+            name: tool.name,
+            config: {
+              description: tool.config.description,
+              inputSchema: tool.config.inputSchema as unknown, // Cast to unknown for SDK interface
+            },
+            // Adapt callback to match SDK's expected signature (args, extra) => result
+            callback: (args: unknown): Promise<ToolResponse> =>
+              tool.callback(args as Record<string, unknown>),
+          }));
+
+          // Use registerTools with proper types and tracking
+          const registeredTools = registerAndTrackTools(server, toolRegistrations);
           log('info', `✅ Registered ${registeredTools.length} tools from '${workflowName}'`);
           // registerTools() automatically sends tool list change notification internally
-        } catch (error) {
-          log('error', `Failed to register tools from '${workflowName}': ${error}`);
-        }
-      } else if (typeof (server as any).registerTool === 'function') {
-        // Use registerTool (fewer notifications than tool())
-        log('info', `🚀 Enabling ${toolsToRegister.length} tools from '${workflowName}' workflow`);
-        for (const toolToRegister of toolsToRegister) {
-          try {
-            (server as any).registerTool(
-              toolToRegister.name,
-              toolToRegister.config,
-              toolToRegister.callback,
-            );
-            log('debug', `Registered tool: ${toolToRegister.name}`);
-          } catch (error) {
-            log('error', `Failed to register tool '${toolToRegister.name}': ${error}`);
-          }
+        } else {
+          log(
+            'info',
+            `All ${toolsToRegister.length} tools from '${workflowName}' were already registered`,
+          );
         }
-        log('info', `✅ Registered ${toolsToRegister.length} tools from '${workflowName}'`);
-      } else {
-        // Final fallback to tool() method (most notifications)
-        log('info', `🚀 Enabling ${toolsToRegister.length} tools from '${workflowName}' workflow`);
+      } catch (error) {
+        log('error', `Failed to register tools from '${workflowName}': ${error}`);
+        // Fallback to simplified tool registration one at a time
+        log(
+          'info',
+          `🚀 Fallback: Enabling ${toolsToRegister.length} tools individually from '${workflowName}' workflow`,
+        );
         for (const toolToRegister of toolsToRegister) {
           try {
-            server.tool(
-              toolToRegister.name,
-              toolToRegister.config.description,
-              toolToRegister.config.inputSchema,
-              toolToRegister.callback,
-            );
+            // Use the simplified registerTools method with single tool to avoid type complexity
+            const singleToolRegistration = [
+              {
+                name: toolToRegister.name,
+                config: {
+                  description: toolToRegister.config.description,
+                  inputSchema: toolToRegister.config.inputSchema as unknown, // Cast to unknown for SDK interface
+                },
+                // Adapt callback to match SDK's expected signature
+                callback: (args: unknown): Promise<ToolResponse> =>
+                  toolToRegister.callback(args as Record<string, unknown>),
+              },
+            ];
+            registerAndTrackTools(server, singleToolRegistration);
             log('debug', `Registered tool: ${toolToRegister.name}`);
-          } catch (error) {
-            log('error', `Failed to register tool '${toolToRegister.name}': ${error}`);
+          } catch (toolError) {
+            log('error', `Failed to register tool '${toolToRegister.name}': ${toolError}`);
           }
         }
         log('info', `✅ Registered ${toolsToRegister.length} tools from '${workflowName}'`);
@@ -224,32 +213,8 @@ export async function enableWorkflows(
     }
   }
 
-  // Notify the client about the tool list change
-  // Only send manual notifications if we're not using registerTools (which sends automatically)
-  let needsManualNotification = true;
-  
-  for (const workflowName of workflowNames) {
-    if (typeof (server as any).registerTools === 'function') {
-      needsManualNotification = false;
-      break;
-    }
-  }
-  
-  if (needsManualNotification) {
-    try {
-      if (typeof (server as any).sendToolListChanged === 'function') {
-        (server as any).sendToolListChanged();
-        log('debug', 'Sent tool list changed notification');
-      } else if (server.notifyToolsChanged) {
-        await server.notifyToolsChanged();
-        log('debug', 'Notified client of tool list changes (fallback)');
-      }
-    } catch (error) {
-      log('warn', `Failed to notify client of tool changes: ${error}`);
-    }
-  } else {
-    log('debug', 'Skipping manual notification - registerTools() handles notifications automatically');
-  }
+  // No manual notification needed - registerTools() handles notifications automatically
+  log('debug', 'Tool list change notifications handled automatically by registerTools()');
 
   log(
     'info',

src/index.ts

@@ -25,7 +25,6 @@ import { log } from './utils/logger.js';
 
 // Import version
 import { version } from './version.js';
-import { loadPlugins } from './core/plugin-registry.js';
 
 // Import xcodemake utilities
 import { isXcodemakeEnabled, isXcodemakeAvailable } from './utils/xcodemake.js';
@@ -35,16 +34,13 @@ import process from 'node:process';
 
 // Import resource management
 import { registerResources } from './core/resources.js';
+import { registerDiscoveryTools, registerAllToolsStatic } from './utils/tool-registry.js';
 
 /**
  * Main function to start the server
  */
 async function main(): Promise<void> {
   try {
-    // Increase stdout maxListeners to prevent EventEmitter memory leak warnings
-    // during bulk tool registration in dynamic mode (80+ tools)
-    process.stdout.setMaxListeners(100);
-    
     // Check if xcodemake is enabled and available
     if (isXcodemakeEnabled()) {
       log('info', 'xcodemake is enabled, checking if available...');
@@ -67,37 +63,20 @@ async function main(): Promise<void> {
     // Make server available globally for dynamic tools
     (globalThis as { mcpServer?: McpServer }).mcpServer = server;
 
-    // Check if dynamic tools mode is enabled
-    const isDynamicMode = process.env.XCODEBUILDMCP_DYNAMIC_TOOLS === 'true';
-
-    if (isDynamicMode) {
-      // DYNAMIC MODE: Only load discovery tools initially
-      log('info', '🚀 Initializing server in dynamic mode...');
-      const plugins = await loadPlugins();
-      let registeredCount = 0;
-      
-      // Only register discovery tools initially
-      for (const plugin of plugins.values()) {
-        // Only load discover_tools and discovery-related tools initially
-        if (plugin.name === 'discover_tools' || plugin.name === 'discover_projs') {
-          server.tool(plugin.name, plugin.description ?? '', plugin.schema, plugin.handler);
-          registeredCount++;
-        }
-      }
-      log('info', `✅ Registered ${registeredCount} discovery tools in dynamic mode.`);
-      log('info', 'Use discover_tools to enable additional workflows based on your task.');
+    // Check if dynamic tools mode is explicitly disabled
+    const isDynamicModeEnabled = process.env.XCODEBUILDMCP_DYNAMIC_TOOLS === 'true';
+
+    if (isDynamicModeEnabled) {
+      // DYNAMIC MODE: Start with discovery tools only
+      log('info', '🚀 Initializing server in dynamic tools mode...');
+      await registerDiscoveryTools(server);
+      log('info', '💡 Use discover_tools to enable additional workflows based on your task.');
     } else {
-      // STATIC MODE: Load all tools immediately  
-      log('info', '🚀 Initializing server in static mode...');
-      const plugins = await loadPlugins();
-      let registeredCount = 0;
-      for (const plugin of plugins.values()) {
-        server.tool(plugin.name, plugin.description ?? '', plugin.schema, plugin.handler);
-        registeredCount++;
-      }
-      log('info', `✅ Registered ${registeredCount} tools in static mode.`);
+      // EXPLICIT STATIC MODE: Load all tools immediately
+      log('info', '🚀 Initializing server in static tools mode...');
+      await registerAllToolsStatic(server);
     }
-    
+
     await registerResources(server);
 
     // Start the server

src/mcp/tools/discovery/__tests__/discover_tools.test.ts

@@ -116,7 +116,7 @@ describe('discover_tools', () => {
 
     it('should have correct description', () => {
       expect(discoverTools.description).toBe(
-        'Analyzes a natural language task description to enable a relevant set of Xcode and Apple development tools for the current session.',
+        'Analyzes a natural language task description to enable a relevant set of Xcode and Apple development tools. For best results, specify the target platform (iOS, macOS, watchOS, tvOS, visionOS) and project type (.xcworkspace or .xcodeproj).',
       );
     });
 

src/utils/capabilities.ts

@@ -11,6 +11,7 @@ export * from './template-manager.js';
 export * from './test-common.js';
 export * from './xcodemake.js';
 export * from './environment.js';
+export * from './tool-registry.js';
 export * from '../version.js';
 export * from '../core/dynamic-tools.js';
 export * from '../core/plugin-registry.js';