Xcode MCP Server

Instructions

Implementation Reference

• src/index.ts:135-155 (handler)

  Executes the tool logic for xcode_show_sdk_info by stripping the 'xcode_' prefix to get 'show_sdk_info', calling CommandExecutor.executeCommand, and formatting the output response.

  // Handle Xcode commands
  // Remove 'xcode_' prefix if present
  const commandName = name.startsWith('xcode_') ? name.slice(6) : name;
  const result = await this.commandExecutor.executeCommand(commandName, args);
  
  let responseText = result.output;
  if (result.error) {
    responseText += `\n\nWarnings/Errors:\n${result.error}`;
  }
  if (!result.success) {
    responseText = `Command failed: ${result.error}\n\nCommand executed: ${result.command}`;
  }
  
  return {
    content: [
      {
        type: 'text',
        text: responseText,
      },
    ],
  };

• src/command-executor.ts:281-306 (schema)

  Dynamically generates the tool name 'xcode_show_sdk_info' (from command 'show_sdk_info') and its inputSchema based on the command parameters definition.

  generateMCPToolDefinitions(): Array<{
    name: string;
    description: string;
    inputSchema: any;
  }> {
    return Object.entries(this.commands).map(([name, command]) => ({
      name: `xcode_${name}`,
      description: command.description,
      inputSchema: {
        type: 'object',
        properties: command.parameters ? Object.fromEntries(
          Object.entries(command.parameters).map(([paramName, paramDef]) => [
            paramName,
            {
              type: paramDef.type,
              description: paramDef.description,
              ...(paramDef.default !== undefined && { default: paramDef.default })
            }
          ])
        ) : {},
        required: command.parameters ? Object.entries(command.parameters)
          .filter(([_, paramDef]) => paramDef.required)
          .map(([paramName]) => paramName) : []
      }
    }));
  }

• src/index.ts:87-89 (registration)

  Registers the ListToolsRequestSchema handler which returns the list of available tools including 'xcode_show_sdk_info'.

  this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [...tools, ...webMonitorTools],
  }));

• src/command-executor.ts:124-162 (handler)

  Core execution logic for the 'show_sdk_info' command: validates params, builds shell command by templating, executes via child_process.exec, returns stdout/stderr.

  async executeCommand(name: string, args: Record<string, any> = {}): Promise<{
    success: boolean;
    output: string;
    error?: string;
    command: string;
  }> {
    const command = this.getCommand(name);
    if (!command) {
      throw new Error(`Command '${name}' not found`);
    }
  
    this.validateParameters(command, args);
  
    // Handle internal commands
    if (command.command.startsWith('internal:')) {
      return await this.executeInternalCommand(command, args);
    }
  
    // Handle external commands
    const builtCommand = this.buildCommand(command, args);
  
    try {
      const { stdout, stderr } = await execAsync(builtCommand);
      
      return {
        success: true,
        output: stdout,
        error: stderr || undefined,
        command: builtCommand
      };
    } catch (error) {
      return {
        success: false,
        output: '',
        error: error instanceof Error ? error.message : String(error),
        command: builtCommand
      };
    }
  }

• src/command-executor.ts:85-122 (helper)

  Builds the actual shell command string for execution by replacing placeholders {param} in the command template from commands.json with provided arguments.

  buildCommand(command: XcodeCommand, args: Record<string, any>): string {
    let builtCommand = command.command;
  
    // Replace required parameters
    if (command.parameters) {
      for (const [paramName, paramDef] of Object.entries(command.parameters)) {
        const value = args[paramName] !== undefined ? args[paramName] : paramDef.default;
        
        if (paramDef.type === 'boolean') {
          // Handle boolean parameters
          if (value === true) {
            // Replace placeholder with the template if true
            builtCommand = builtCommand.replace(`{${paramName}}`, paramDef.template || '');
          } else {
            // Remove placeholder if false
            builtCommand = builtCommand.replace(`{${paramName}}`, '');
          }
        } else if (value !== undefined && value !== null && value !== '') {
          if (paramDef.template) {
            // Use custom template for parameter
            const paramValue = paramDef.template.replace(`{${paramName}}`, value);
            builtCommand = builtCommand.replace(`{${paramName}}`, paramValue);
          } else {
            // Direct replacement
            builtCommand = builtCommand.replace(`{${paramName}}`, value);
          }
        } else {
          // Remove optional parameter placeholders
          builtCommand = builtCommand.replace(new RegExp(`\\s*\\{${paramName}\\}`, 'g'), '');
        }
      }
    }
  
    // Clean up any remaining placeholder patterns
    builtCommand = builtCommand.replace(/\s+/g, ' ').trim();
    
    return builtCommand;
  }