sl-test

Instructions

Implementation Reference

• src/tools/build_settings.ts:84-151 (handler)

  Core handler logic shared between project and workspace scheme listing tools. Executes 'xcodebuild -list', parses the schemes section from output, lists them, and suggests next steps with other tools.

  async function _handleListSchemesLogic(params: {
    workspacePath?: string;
    projectPath?: string;
  }): Promise<ToolResponse> {
    log('info', 'Listing schemes');
  
    try {
      // For listing schemes, we can't use executeXcodeBuild directly since it's not a standard action
      // We need to create a custom command with -list flag
      const command = ['xcodebuild', '-list'];
  
      if (params.workspacePath) {
        command.push('-workspace', params.workspacePath);
      } else if (params.projectPath) {
        command.push('-project', params.projectPath);
      } // No else needed, one path is guaranteed by callers
  
      const result = await executeCommand(command, 'List Schemes');
  
      if (!result.success) {
        return createTextResponse(`Failed to list schemes: ${result.error}`, true);
      }
  
      // Extract schemes from the output
      const schemesMatch = result.output.match(/Schemes:([\s\S]*?)(?=\n\n|$)/);
  
      if (!schemesMatch) {
        return createTextResponse('No schemes found in the output', true);
      }
  
      const schemeLines = schemesMatch[1].trim().split('\n');
      const schemes = schemeLines.map((line) => line.trim()).filter((line) => line);
  
      // Prepare next steps with the first scheme if available
      let nextStepsText = '';
      if (schemes.length > 0) {
        const firstScheme = schemes[0];
        const projectOrWorkspace = params.workspacePath ? 'workspace' : 'project';
        const path = params.workspacePath || params.projectPath;
  
        nextStepsText = `Next Steps:
  1. Build the app: ${projectOrWorkspace === 'workspace' ? 'macos_build_workspace' : 'macos_build_project'}({ ${projectOrWorkspace}Path: "${path}", scheme: "${firstScheme}" })
     or for iOS: ${projectOrWorkspace === 'workspace' ? 'ios_simulator_build_by_name_workspace' : 'ios_simulator_build_by_name_project'}({ ${projectOrWorkspace}Path: "${path}", scheme: "${firstScheme}", simulatorName: "iPhone 16" })
  2. Show build settings: ${projectOrWorkspace === 'workspace' ? 'show_build_set_ws' : 'show_build_set_proj'}({ ${projectOrWorkspace}Path: "${path}", scheme: "${firstScheme}" })`;
      }
  
      return {
        content: [
          {
            type: 'text',
            text: `✅ Available schemes:`,
          },
          {
            type: 'text',
            text: schemes.join('\n'),
          },
          {
            type: 'text',
            text: nextStepsText,
          },
        ],
      };
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      log('error', `Error listing schemes: ${errorMessage}`);
      return createTextResponse(`Error listing schemes: ${errorMessage}`, true);
    }
  }

• src/tools/build_settings.ts:229-245 (registration)

  Specific registration function for the 'list_schems_proj' tool, defining its name, description, input schema, and handler that validates projectPath and delegates to _handleListSchemesLogic.

  export function registerListSchemesProjectTool(server: McpServer): void {
    registerTool<BaseProjectParams>(
      server,
      'list_schems_proj',
      "Lists available schemes in the project file. IMPORTANT: Requires projectPath. Example: list_schems_proj({ projectPath: '/path/to/MyProject.xcodeproj' })",
      {
        projectPath: projectPathSchema,
      },
      async (params: BaseProjectParams) => {
        // Validate required parameters
        const projectValidation = validateRequiredParam('projectPath', params.projectPath);
        if (!projectValidation.isValid) return projectValidation.errorResponse!;
  
        return _handleListSchemesLogic(params);
      },
    );
  }

• src/tools/common.ts:23-23 (schema)

  Zod schema definition for the required projectPath input parameter used by 'list_schems_proj' and other project-based tools.

  export const projectPathSchema = z.string().describe('Path to the .xcodeproj file (Required)');

• src/utils/register-tools.ts:118-122 (registration)

  Top-level registration entry that includes the registerListSchemesProjectTool in the toolRegistrations array, associating it with PROJECT_DISCOVERY group and an environment variable for conditional enabling.

  {
    register: registerListSchemesProjectTool,
    groups: [ToolGroup.PROJECT_DISCOVERY],
    envVar: 'XCODEBUILDMCP_TOOL_LIST_SCHEMES_PROJECT',
  },

• src/tools/common.ts:160-179 (helper)

  Utility function registerTool used by all tools to register with the MCP server, wrapping the custom handler to match MCP SDK expectations.

  export function registerTool<T extends object>(
    server: McpServer,
    name: string,
    description: string,
    schema: Record<string, z.ZodType>,
    handler: (params: T) => Promise<ToolResponse>,
  ): void {
    // Create a wrapper handler that matches the signature expected by server.tool
    const wrappedHandler = (
      args: Record<string, unknown>,
      _extra: unknown,
    ): Promise<ToolResponse> => {
      // Assert the type *before* calling the original handler
      // This confines the type assertion to one place
      const typedParams = args as T;
      return handler(typedParams);
    };
  
    server.tool(name, description, schema, wrappedHandler);
  }