sl-test

Instructions

Implementation Reference

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

  Core handler logic shared across app path tools. Executes xcodebuild -showBuildSettings for iOS device (generic/platform=iOS), extracts and returns the built app bundle path.

  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:264-277 (handler)

  Specific tool handler for get_ios_dev_app_path_ws: validates workspacePath and scheme, calls shared _handleGetAppPathLogic with iOS device platform.

  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!;
  
    return _handleGetAppPathLogic({
      ...params,
      configuration: params.configuration ?? 'Debug',
      platform: XcodePlatform.iOS,
      useLatestOS: true,
    });
  },

• src/tools/app_path.ts:253-279 (registration)

  Registers the get_ios_dev_app_path_ws MCP tool with server, defining name, description, input schema, and handler.

  export function registerGetiOSDeviceAppPathWorkspaceTool(server: McpServer): void {
    type Params = BaseWorkspaceParams & { configuration?: string };
    registerTool<Params>(
      server,
      'get_ios_dev_app_path_ws',
      "Gets the app bundle path for an iOS physical device application using a workspace. IMPORTANT: Requires workspacePath and scheme. Example: get_ios_dev_app_path_ws({ workspacePath: '/path/to/workspace', scheme: 'MyScheme' })",
      {
        workspacePath: workspacePathSchema,
        scheme: schemeSchema,
        configuration: configurationSchema,
      },
      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!;
  
        return _handleGetAppPathLogic({
          ...params,
          configuration: params.configuration ?? 'Debug',
          platform: XcodePlatform.iOS,
          useLatestOS: true,
        });
      },
    );
  }

• src/tools/app_path.ts:259-263 (schema)

  Input parameter schema for the tool: workspacePath (string, required), scheme (string, required), configuration (string, optional). Schemas imported from ./common.ts

  {
    workspacePath: workspacePathSchema,
    scheme: schemeSchema,
    configuration: configurationSchema,
  },

• src/utils/register-tools.ts:276-279 (registration)

  Top-level tool registration configuration: enables the iOS device app path workspace tool via environment variable and tool groups.

    register: registerGetiOSDeviceAppPathWorkspaceTool,
    groups: [ToolGroup.IOS_DEVICE_WORKFLOW, ToolGroup.APP_DEPLOYMENT, ToolGroup.PROJECT_DISCOVERY],
    envVar: 'XCODEBUILDMCP_TOOL_GET_IOS_DEVICE_APP_PATH_WORKSPACE',
  },