sl-test

Instructions

Implementation Reference

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

  Core handler logic shared across app path tools. Runs `xcodebuild -showBuildSettings` with platform=iOS destination to extract BUILT_PRODUCTS_DIR and FULL_PRODUCT_NAME, constructing the .app path for iOS device builds.

  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:284-310 (registration)

  Registers the 'get_ios_dev_app_path_proj' tool using registerTool, defining name, description, input schema, and handler that validates params and calls the core _handleGetAppPathLogic with iOS device settings.

  export function registerGetiOSDeviceAppPathProjectTool(server: McpServer): void {
    type Params = BaseProjectParams & { configuration?: string };
    registerTool<Params>(
      server,
      'get_ios_dev_app_path_proj',
      "Gets the app bundle path for an iOS physical device application using a project file. IMPORTANT: Requires projectPath and scheme. Example: get_ios_dev_app_path_proj({ projectPath: '/path/to/project.xcodeproj', scheme: 'MyScheme' })",
      {
        projectPath: projectPathSchema,
        scheme: schemeSchema,
        configuration: configurationSchema,
      },
      async (params: Params) => {
        const projectValidation = validateRequiredParam('projectPath', params.projectPath);
        if (!projectValidation.isValid) return projectValidation.errorResponse!;
  
        const schemeValidation = validateRequiredParam('scheme', params.scheme);
        if (!schemeValidation.isValid) return schemeValidation.errorResponse!;
  
        return _handleGetAppPathLogic({
          ...params,
          configuration: params.configuration ?? 'Debug',
          platform: XcodePlatform.iOS,
          useLatestOS: true,
        });
      },
    );
  }

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

  Zod schemas for the input parameters: projectPath, scheme (required), configuration (optional) used by the get_ios_dev_app_path_proj tool.

  export const workspacePathSchema = z.string().describe('Path to the .xcworkspace file (Required)');
  export const projectPathSchema = z.string().describe('Path to the .xcodeproj file (Required)');
  export const schemeSchema = z.string().describe('The scheme to use (Required)');
  export const configurationSchema = z
    .string()
    .optional()
    .describe('Build configuration (Debug, Release, etc.)');

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

  Generic helper function registerTool that wraps the tool handler and registers it with the MCP server using server.tool().

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

• src/utils/register-tools.ts:280-283 (registration)

  Invocation of the register function in the toolRegistrations array, which conditionally registers the tool based on environment variables and tool groups.

  {
    register: registerGetiOSDeviceAppPathProjectTool,
    groups: [ToolGroup.IOS_DEVICE_WORKFLOW, ToolGroup.APP_DEPLOYMENT, ToolGroup.PROJECT_DISCOVERY],
    envVar: 'XCODEBUILDMCP_TOOL_GET_IOS_DEVICE_APP_PATH_PROJECT',