fix: properly type platform mapping and ensure simulator platforms are mapped to device equivalents for clean operations

- Fix TypeScript error by properly typing cleanPlatformMap as Partial<Record<XcodePlatform, XcodePlatform>>
- Simulator platforms (iOS Simulator, watchOS Simulator, etc.) are mapped to their device equivalents (iOS, watchOS, etc.) since build products are shared between device and simulator platforms
- This allows clean operations to work correctly for all platform types including simulators
- All tests passing and local testing confirms iOS, iOS Simulator, and macOS platforms work correctly

Author: cameroncooke

src/mcp/tools/utilities/__tests__/clean.test.ts

@@ -50,54 +50,75 @@ describe('clean (unified) tool', () => {
   });
 
   it('uses iOS platform by default', async () => {
-    const mock = createMockExecutor({ success: true, output: 'clean success' });
-    const result = await cleanLogic({ projectPath: '/p.xcodeproj', scheme: 'App' } as any, mock);
+    let capturedCommand: string[] = [];
+    const mockExecutor = async (command: string[]) => {
+      capturedCommand = command;
+      return { success: true, output: 'clean success' };
+    };
+
+    const result = await cleanLogic(
+      { projectPath: '/p.xcodeproj', scheme: 'App' } as any,
+      mockExecutor,
+    );
     expect(result.isError).not.toBe(true);
-    
-    // Check that the executor was called with iOS platform arguments
-    expect(mock).toHaveBeenCalled();
-    const commandArgs = mock.mock.calls[0][0];
-    expect(commandArgs).toContain('-destination');
-    expect(commandArgs).toContain('platform=iOS');
+
+    // Check that the command contains iOS platform destination
+    const commandStr = capturedCommand.join(' ');
+    expect(commandStr).toContain('-destination');
+    expect(commandStr).toContain('platform=iOS');
   });
 
   it('accepts custom platform parameter', async () => {
-    const mock = createMockExecutor({ success: true, output: 'clean success' });
-    const result = await cleanLogic({ 
-      projectPath: '/p.xcodeproj', 
-      scheme: 'App',
-      platform: 'macOS'
-    } as any, mock);
+    let capturedCommand: string[] = [];
+    const mockExecutor = async (command: string[]) => {
+      capturedCommand = command;
+      return { success: true, output: 'clean success' };
+    };
+
+    const result = await cleanLogic(
+      {
+        projectPath: '/p.xcodeproj',
+        scheme: 'App',
+        platform: 'macOS',
+      } as any,
+      mockExecutor,
+    );
     expect(result.isError).not.toBe(true);
-    
-    // Check that the executor was called with macOS platform arguments
-    expect(mock).toHaveBeenCalled();
-    const commandArgs = mock.mock.calls[0][0];
-    expect(commandArgs).toContain('-destination');
-    expect(commandArgs).toContain('platform=macOS');
+
+    // Check that the command contains macOS platform destination
+    const commandStr = capturedCommand.join(' ');
+    expect(commandStr).toContain('-destination');
+    expect(commandStr).toContain('platform=macOS');
   });
 
-  it('accepts iOS Simulator platform parameter', async () => {
-    const mock = createMockExecutor({ success: true, output: 'clean success' });
-    const result = await cleanLogic({ 
-      projectPath: '/p.xcodeproj', 
-      scheme: 'App',
-      platform: 'iOS Simulator'
-    } as any, mock);
+  it('accepts iOS Simulator platform parameter (maps to iOS for clean)', async () => {
+    let capturedCommand: string[] = [];
+    const mockExecutor = async (command: string[]) => {
+      capturedCommand = command;
+      return { success: true, output: 'clean success' };
+    };
+
+    const result = await cleanLogic(
+      {
+        projectPath: '/p.xcodeproj',
+        scheme: 'App',
+        platform: 'iOS Simulator',
+      } as any,
+      mockExecutor,
+    );
     expect(result.isError).not.toBe(true);
-    
-    // Check that the executor was called with iOS Simulator platform arguments
-    expect(mock).toHaveBeenCalled();
-    const commandArgs = mock.mock.calls[0][0];
-    expect(commandArgs).toContain('-destination');
-    expect(commandArgs).toContain('platform=iOS Simulator');
+
+    // For clean operations, iOS Simulator should be mapped to iOS platform
+    const commandStr = capturedCommand.join(' ');
+    expect(commandStr).toContain('-destination');
+    expect(commandStr).toContain('platform=iOS');
   });
 
   it('handler validation: rejects invalid platform values', async () => {
     const result = await (tool as any).handler({
       projectPath: '/p.xcodeproj',
       scheme: 'App',
-      platform: 'InvalidPlatform'
+      platform: 'InvalidPlatform',
     });
     expect(result.isError).toBe(true);
     const text = String(result.content?.[1]?.text ?? result.content?.[0]?.text ?? '');

src/mcp/tools/utilities/clean.ts

@@ -33,9 +33,21 @@ const baseOptions = {
       'If true, prefers xcodebuild over the experimental incremental build system, useful for when incremental build system fails.',
     ),
   platform: z
-    .enum(['macOS', 'iOS', 'iOS Simulator', 'watchOS', 'watchOS Simulator', 'tvOS', 'tvOS Simulator', 'visionOS', 'visionOS Simulator'])
+    .enum([
+      'macOS',
+      'iOS',
+      'iOS Simulator',
+      'watchOS',
+      'watchOS Simulator',
+      'tvOS',
+      'tvOS Simulator',
+      'visionOS',
+      'visionOS Simulator',
+    ])
     .optional()
-    .describe('Optional: Platform to clean for (defaults to iOS). Choose from macOS, iOS, iOS Simulator, watchOS, watchOS Simulator, tvOS, tvOS Simulator, visionOS, visionOS Simulator'),
+    .describe(
+      'Optional: Platform to clean for (defaults to iOS). Choose from macOS, iOS, iOS Simulator, watchOS, watchOS Simulator, tvOS, tvOS Simulator, visionOS, visionOS Simulator',
+    ),
 };
 
 const baseSchemaObject = z.object({
@@ -71,11 +83,32 @@ export async function cleanLogic(
       'Invalid parameters:\nscheme: scheme is required when workspacePath is provided.',
     );
   }
-  
+
   // Use provided platform or default to iOS
   const targetPlatform = params.platform ?? 'iOS';
-  const platformEnum = XcodePlatform[targetPlatform as keyof typeof XcodePlatform];
-  
+
+  // Map human-friendly platform names to XcodePlatform enum values
+  // This is safer than direct key lookup and handles the space-containing simulator names
+  const platformMap = {
+    macOS: XcodePlatform.macOS,
+    iOS: XcodePlatform.iOS,
+    'iOS Simulator': XcodePlatform.iOSSimulator,
+    watchOS: XcodePlatform.watchOS,
+    'watchOS Simulator': XcodePlatform.watchOSSimulator,
+    tvOS: XcodePlatform.tvOS,
+    'tvOS Simulator': XcodePlatform.tvOSSimulator,
+    visionOS: XcodePlatform.visionOS,
+    'visionOS Simulator': XcodePlatform.visionOSSimulator,
+  };
+
+  const platformEnum = platformMap[targetPlatform];
+  if (!platformEnum) {
+    return createErrorResponse(
+      'Parameter validation failed',
+      `Invalid parameters:\nplatform: unsupported value "${targetPlatform}".`,
+    );
+  }
+
   const hasProjectPath = typeof params.projectPath === 'string';
   const typedParams: SharedBuildParams = {
     ...(hasProjectPath
@@ -89,10 +122,22 @@ export async function cleanLogic(
     extraArgs: params.extraArgs,
   };
 
+  // For clean operations, simulator platforms should be mapped to their device equivalents
+  // since clean works at the build product level, not runtime level, and build products
+  // are shared between device and simulator platforms
+  const cleanPlatformMap: Partial<Record<XcodePlatform, XcodePlatform>> = {
+    [XcodePlatform.iOSSimulator]: XcodePlatform.iOS,
+    [XcodePlatform.watchOSSimulator]: XcodePlatform.watchOS,
+    [XcodePlatform.tvOSSimulator]: XcodePlatform.tvOS,
+    [XcodePlatform.visionOSSimulator]: XcodePlatform.visionOS,
+  };
+
+  const cleanPlatform = cleanPlatformMap[platformEnum] ?? platformEnum;
+
   return executeXcodeBuildCommand(
     typedParams,
     {
-      platform: platformEnum,
+      platform: cleanPlatform,
       logPrefix: 'Clean',
     },
     false,