sl-test

Instructions

Implementation Reference

• src/tools/app_path.ts:49-180 (handler)

  Core handler logic shared across app path tools. Runs `xcodebuild -showBuildSettings` to extract BUILT_PRODUCTS_DIR and FULL_PRODUCT_NAME, constructs app path, and returns formatted response with next steps.

  async function _handleGetAppPathLogic(params: {
    workspacePath?: string;
    projectPath?: string;
    scheme: string;
    configuration: string;
    platform: XcodePlatform;
    simulatorName?: string;
    simulatorId?: string;
    useLatestOS: boolean;
    arch?: string;
  }): Promise<ToolResponse> {
    log('info', `Getting app path for scheme ${params.scheme} on platform ${params.platform}`);
  
    try {
      // Create the command array for xcodebuild with -showBuildSettings option
      const command = ['xcodebuild', '-showBuildSettings'];
  
      // Add the workspace or project
      if (params.workspacePath) {
        command.push('-workspace', params.workspacePath);
      } else if (params.projectPath) {
        command.push('-project', params.projectPath);
      }
  
      // Add the scheme and configuration
      command.push('-scheme', params.scheme);
      command.push('-configuration', params.configuration);
  
      // Handle destination based on platform
      const isSimulatorPlatform = [
        XcodePlatform.iOSSimulator,
        XcodePlatform.watchOSSimulator,
        XcodePlatform.tvOSSimulator,
        XcodePlatform.visionOSSimulator,
      ].includes(params.platform);
  
      let destinationString = '';
  
      if (isSimulatorPlatform) {
        if (params.simulatorId) {
          destinationString = `platform=${params.platform},id=${params.simulatorId}`;
        } else if (params.simulatorName) {
          destinationString = `platform=${params.platform},name=${params.simulatorName}${params.useLatestOS ? ',OS=latest' : ''}`;
        } else {
          return createTextResponse(
            `For ${params.platform} platform, either simulatorId or simulatorName must be provided`,
            true,
          );
        }
      } else if (params.platform === XcodePlatform.macOS) {
        destinationString = constructDestinationString(
          params.platform,
          undefined,
          undefined,
          false,
          params.arch,
        );
      } else if (params.platform === XcodePlatform.iOS) {
        destinationString = 'generic/platform=iOS';
      } else if (params.platform === XcodePlatform.watchOS) {
        destinationString = 'generic/platform=watchOS';
      } else if (params.platform === XcodePlatform.tvOS) {
        destinationString = 'generic/platform=tvOS';
      } else if (params.platform === XcodePlatform.visionOS) {
        destinationString = 'generic/platform=visionOS';
      } else {
        return createTextResponse(`Unsupported platform: ${params.platform}`, true);
      }
  
      command.push('-destination', destinationString);
  
      // Execute the command directly
      const result = await executeCommand(command, 'Get App Path');
  
      if (!result.success) {
        return createTextResponse(`Failed to get app path: ${result.error}`, true);
      }
  
      if (!result.output) {
        return createTextResponse('Failed to extract build settings output from the result.', true);
      }
  
      const buildSettingsOutput = result.output;
      const builtProductsDirMatch = buildSettingsOutput.match(/BUILT_PRODUCTS_DIR = (.+)$/m);
      const fullProductNameMatch = buildSettingsOutput.match(/FULL_PRODUCT_NAME = (.+)$/m);
  
      if (!builtProductsDirMatch || !fullProductNameMatch) {
        return createTextResponse(
          'Failed to extract app path from build settings. Make sure the app has been built first.',
          true,
        );
      }
  
      const builtProductsDir = builtProductsDirMatch[1].trim();
      const fullProductName = fullProductNameMatch[1].trim();
      const appPath = `${builtProductsDir}/${fullProductName}`;
  
      let nextStepsText = '';
      if (params.platform === XcodePlatform.macOS) {
        nextStepsText = `Next Steps:
  1. Get bundle ID: get_macos_bundle_id({ appPath: "${appPath}" })
  2. Launch the app: launch_macos_app({ appPath: "${appPath}" })`;
      } else if (params.platform === XcodePlatform.iOSSimulator) {
        nextStepsText = `Next Steps:
  1. Get bundle ID: get_ios_bundle_id({ appPath: "${appPath}" })
  2. Boot simulator: boot_simulator({ simulatorUuid: "SIMULATOR_UUID" })
  3. Install app: install_app_in_simulator({ simulatorUuid: "SIMULATOR_UUID", appPath: "${appPath}" })
  4. Launch app: launch_app_in_simulator({ simulatorUuid: "SIMULATOR_UUID", bundleId: "BUNDLE_ID" })`;
      } else if (params.platform === XcodePlatform.iOS) {
        nextStepsText = `Next Steps:
  1. Get bundle ID: get_ios_bundle_id({ appPath: "${appPath}" })
  2. Use Xcode to install the app on your connected iOS device`;
      }
  
      return {
        content: [
          {
            type: 'text',
            text: `✅ App path retrieved successfully: ${appPath}`,
          },
          {
            type: 'text',
            text: nextStepsText,
          },
        ],
      };
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      log('error', `Error retrieving app path: ${errorMessage}`);
      return createTextResponse(`Error retrieving app path: ${errorMessage}`, true);
    }
  }

• src/tools/app_path.ts:390-427 (registration)

  Specific registration function for the 'get_sim_app_path_id_ws' tool, defining schema, description, and handler wrapper with parameter validation.

  /**
   * Registers the get_sim_app_path_id_ws tool
   */
  export function registerGetSimulatorAppPathByIdWorkspaceTool(server: McpServer): void {
    type Params = BaseWorkspaceParams & BaseAppPathSimulatorIdParams;
    registerTool<Params>(
      server,
      'get_sim_app_path_id_ws',
      "Gets the app bundle path for a simulator by UUID using a workspace. IMPORTANT: Requires workspacePath, scheme, platform, and simulatorId. Example: get_sim_app_path_id_ws({ workspacePath: '/path/to/workspace', scheme: 'MyScheme', platform: 'iOS Simulator', simulatorId: 'SIMULATOR_UUID' })",
      {
        workspacePath: workspacePathSchema,
        scheme: schemeSchema,
        platform: platformSimulatorSchema,
        simulatorId: simulatorIdSchema,
        configuration: configurationSchema,
        useLatestOS: useLatestOSSchema,
      },
      async (params: Params) => {
        const workspaceValidation = validateRequiredParam('workspacePath', params.workspacePath);
        if (!workspaceValidation.isValid) return workspaceValidation.errorResponse!;
  
        const schemeValidation = validateRequiredParam('scheme', params.scheme);
        if (!schemeValidation.isValid) return schemeValidation.errorResponse!;
  
        const platformValidation = validateRequiredParam('platform', params.platform);
        if (!platformValidation.isValid) return platformValidation.errorResponse!;
  
        const simulatorIdValidation = validateRequiredParam('simulatorId', params.simulatorId);
        if (!simulatorIdValidation.isValid) return simulatorIdValidation.errorResponse!;
  
        return _handleGetAppPathLogic({
          ...params,
          configuration: params.configuration ?? 'Debug',
          useLatestOS: params.useLatestOS ?? true,
        });
      },
    );
  }

• src/tools/app_path.ts:399-406 (schema)

  Zod schema definition for input parameters of the tool, composing common schemas.

  {
    workspacePath: workspacePathSchema,
    scheme: schemeSchema,
    platform: platformSimulatorSchema,
    simulatorId: simulatorIdSchema,
    configuration: configurationSchema,
    useLatestOS: useLatestOSSchema,
  },

• src/utils/register-tools.ts:303-311 (registration)

  Top-level registration entry that imports and conditionally registers the tool based on environment variable.

  {
    register: registerGetSimulatorAppPathByIdWorkspaceTool,
    groups: [
      ToolGroup.IOS_SIMULATOR_WORKFLOW,
      ToolGroup.APP_DEPLOYMENT,
      ToolGroup.PROJECT_DISCOVERY,
    ],
    envVar: 'XCODEBUILDMCP_TOOL_GET_SIMULATOR_APP_PATH_BY_ID_WORKSPACE',
  },

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

  Generic helper function used by all tool registration functions to register with MCP server, providing Zod schema validation and type-safe handler wrapping.

  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);
  }