fix: classify stderr warnings correctly and prioritize xcresult output

xcodebuild dumps warnings (e.g. "multiple matching destinations") to
stderr. These were indiscriminately tagged as errors, hiding actual test
failure details from xcresult parsing. Now stderr lines containing
WARNING get a warning prefix instead of error, and xcresult test
summaries appear before raw stderr output in the response.

Part of #231

Author: czottmann

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [Unreleased]
+
+### Fixed
+
+- Fixed stderr warnings (e.g. "multiple matching destinations") being reported as errors, hiding actual test failures from xcresult output ([#231](https://github.com/getsentry/XcodeBuildMCP/issues/231))
+
 ## [2.1.0]
 
 ### Added

src/mcp/tools/macos/__tests__/test_macos.test.ts

@@ -3,7 +3,7 @@
  * Following CLAUDE.md testing standards with literal validation
  * Using dependency injection for deterministic testing
  */
-import { describe, it, expect, beforeEach } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import * as z from 'zod';
 import {
   createMockCommandResponse,
@@ -12,7 +12,7 @@ import {
   type FileSystemExecutor,
 } from '../../../../test-utils/mock-executors.ts';
 import { sessionStore } from '../../../../utils/session-store.ts';
-import { schema, handler } from '../test_macos.ts';
+import { handler, schema } from '../test_macos.ts';
 import { testMacosLogic } from '../test_macos.ts';
 
 const createTestFileSystemExecutor = (overrides: Partial<FileSystemExecutor> = {}) =>
@@ -412,7 +412,11 @@ describe('test_macos plugin (unified)', () => {
           });
         }
 
-        return createMockCommandResponse({ success: true, output: '', error: undefined });
+        return createMockCommandResponse({
+          success: true,
+          output: '',
+          error: undefined,
+        });
       };
 
       // Mock file system dependencies
@@ -440,6 +444,89 @@ describe('test_macos plugin (unified)', () => {
       expect(result.isError).toBe(true);
     });
 
+    it('should place xcresult summary before build output on test failure', async () => {
+      let callCount = 0;
+      const mockExecutor = async (
+        command: string[],
+        logPrefix?: string,
+        useShell?: boolean,
+        opts?: { env?: Record<string, string> },
+        detached?: boolean,
+      ) => {
+        callCount++;
+        void logPrefix;
+        void useShell;
+        void opts;
+        void detached;
+
+        // First call is xcodebuild test - fails with a WARNING in stderr
+        if (callCount === 1) {
+          return createMockCommandResponse({
+            success: false,
+            output: '',
+            error:
+              '--- xcodebuild: WARNING: Using the first of multiple matching destinations:\n** TEST FAILED **',
+          });
+        }
+
+        // Second call is xcresulttool - returns failure details
+        if (command.includes('xcresulttool')) {
+          return createMockCommandResponse({
+            success: true,
+            output: JSON.stringify({
+              title: 'Test Results',
+              result: 'FAILED',
+              totalTestCount: 3,
+              passedTests: 1,
+              failedTests: 2,
+              skippedTests: 0,
+              expectedFailures: 0,
+              testFailures: [
+                {
+                  testName: 'testFoo',
+                  targetName: 'MyTests',
+                  failureText: 'XCTAssertEqual failed',
+                },
+              ],
+            }),
+            error: undefined,
+          });
+        }
+
+        return createMockCommandResponse({
+          success: true,
+          output: '',
+          error: undefined,
+        });
+      };
+
+      const mockFileSystemExecutor = createTestFileSystemExecutor({
+        mkdtemp: async () => '/tmp/xcodebuild-test-abc123',
+      });
+
+      const result = await testMacosLogic(
+        {
+          workspacePath: '/path/to/MyProject.xcworkspace',
+          scheme: 'MyScheme',
+        },
+        mockExecutor,
+        mockFileSystemExecutor,
+      );
+
+      expect(result.isError).toBe(true);
+
+      // xcresult summary must appear first
+      const firstContent = result.content[0].text;
+      expect(firstContent).toContain('Test Results Summary');
+      expect(firstContent).toContain('Failed: 2');
+
+      // Build output should come after
+      const allText = result.content.map((c) => c.text).join('\n');
+      const summaryIndex = allText.indexOf('Test Results Summary');
+      const stderrIndex = allText.indexOf('[stderr]');
+      expect(summaryIndex).toBeLessThan(stderrIndex);
+    });
+
     it('should return exact successful test response with optional parameters', async () => {
       // Track command execution calls
       const commandCalls: any[] = [];

src/mcp/tools/macos/test_macos.ts

@@ -14,9 +14,9 @@ import { executeXcodeBuildCommand } from '../../../utils/build/index.ts';
 import { createTextResponse } from '../../../utils/responses/index.ts';
 import { normalizeTestRunnerEnv } from '../../../utils/environment.ts';
 import type {
+  CommandExecOptions,
   CommandExecutor,
   FileSystemExecutor,
-  CommandExecOptions,
 } from '../../../utils/execution/index.ts';
 import {
   getDefaultCommandExecutor,
@@ -294,13 +294,14 @@ export async function testMacosLogic(
       await fileSystemExecutor.rm(tempDir, { recursive: true, force: true });
 
       // Return combined result - preserve isError from testResult (test failures should be marked as errors)
+      // Prioritize xcresult summary over raw stderr output so test failures are visible first
       return {
         content: [
-          ...(testResult.content ?? []),
           {
             type: 'text',
             text: '\nTest Results Summary:\n' + testSummary,
           },
+          ...(testResult.content ?? []),
         ],
         isError: testResult.isError,
       };
@@ -336,7 +337,10 @@ export const handler = createSessionAwareTool<TestMacosParams>({
   getExecutor: getDefaultCommandExecutor,
   requirements: [
     { allOf: ['scheme'], message: 'scheme is required' },
-    { oneOf: ['projectPath', 'workspacePath'], message: 'Provide a project or workspace' },
+    {
+      oneOf: ['projectPath', 'workspacePath'],
+      message: 'Provide a project or workspace',
+    },
   ],
   exclusivePairs: [['projectPath', 'workspacePath']],
 });

src/utils/__tests__/build-utils.test.ts

@@ -2,7 +2,7 @@
  * Tests for build-utils Sentry classification logic
  */
 
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import path from 'node:path';
 import { createMockExecutor } from '../../test-utils/mock-executors.ts';
 import { executeXcodeBuildCommand } from '../build-utils.ts';
@@ -241,6 +241,71 @@ describe('build-utils Sentry Classification', () => {
     });
   });
 
+  describe('Stderr Warning vs Error Classification', () => {
+    it('should classify stderr lines containing WARNING with warning prefix', async () => {
+      const mockExecutor = createMockExecutor({
+        success: false,
+        error: '--- xcodebuild: WARNING: Using the first of multiple matching destinations:',
+        exitCode: 1,
+      });
+
+      const result = await executeXcodeBuildCommand(
+        mockParams,
+        mockPlatformOptions,
+        false,
+        'build',
+        mockExecutor,
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('⚠️ [stderr]');
+      expect(result.content[0].text).toContain('WARNING');
+      expect(result.content[0].text).not.toMatch(/^❌/);
+    });
+
+    it('should classify stderr lines without WARNING with error prefix', async () => {
+      const mockExecutor = createMockExecutor({
+        success: false,
+        error: 'Build failed with errors',
+        exitCode: 1,
+      });
+
+      const result = await executeXcodeBuildCommand(
+        mockParams,
+        mockPlatformOptions,
+        false,
+        'build',
+        mockExecutor,
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('❌ [stderr]');
+    });
+
+    it('should classify mixed stderr lines independently', async () => {
+      const mockExecutor = createMockExecutor({
+        success: false,
+        error:
+          '--- xcodebuild: WARNING: Using the first of multiple matching destinations:\nerror: Build input file not found',
+        exitCode: 1,
+      });
+
+      const result = await executeXcodeBuildCommand(
+        mockParams,
+        mockPlatformOptions,
+        false,
+        'build',
+        mockExecutor,
+      );
+
+      expect(result.isError).toBe(true);
+      // First line is a warning
+      expect(result.content[0].text).toContain('⚠️ [stderr]');
+      // Second line is an error
+      expect(result.content[1].text).toContain('❌ [stderr]');
+    });
+  });
+
   describe('Exit Code Undefined Cases', () => {
     it('should not trigger Sentry logging when exitCode is undefined', async () => {
       const mockExecutor = createMockExecutor({
@@ -385,7 +450,9 @@ describe('build-utils Sentry Classification', () => {
       expect(capturedCommand).toBeDefined();
       expect(capturedCommand).toContain(expectedProjectPath);
       expect(capturedCommand).toContain(expectedDerivedDataPath);
-      expect(capturedOptions).toEqual({ cwd: path.dirname(expectedProjectPath) });
+      expect(capturedOptions).toEqual({
+        cwd: path.dirname(expectedProjectPath),
+      });
     });
   });
 });

src/utils/build-utils.ts

@@ -18,17 +18,17 @@
  */
 
 import { log } from './logger.ts';
-import { XcodePlatform, constructDestinationString } from './xcode.ts';
-import type { CommandExecutor, CommandExecOptions } from './command.ts';
-import type { ToolResponse, SharedBuildParams, PlatformBuildOptions } from '../types/common.ts';
-import { createTextResponse, consolidateContentForClaudeCode } from './validation.ts';
+import { constructDestinationString, XcodePlatform } from './xcode.ts';
+import type { CommandExecOptions, CommandExecutor } from './command.ts';
+import type { PlatformBuildOptions, SharedBuildParams, ToolResponse } from '../types/common.ts';
+import { consolidateContentForClaudeCode, createTextResponse } from './validation.ts';
 import {
-  isXcodemakeEnabled,
-  isXcodemakeAvailable,
-  executeXcodemakeCommand,
-  executeMakeCommand,
   doesMakefileExist,
   doesMakeLogFileExist,
+  executeMakeCommand,
+  executeXcodemakeCommand,
+  isXcodemakeAvailable,
+  isXcodemakeEnabled,
 } from './xcodemake.ts';
 import { sessionStore } from './session-store.ts';
 import path from 'path';
@@ -66,10 +66,12 @@ export async function executeXcodeBuildCommand(
     return text
       .split('\n')
       .map((content) => {
-        if (/(?:^(?:[\w-]+:\s+)?|:\d+:\s+)warning:\s/i.test(content))
+        if (/(?:^(?:[\w-]+:\s+)?|:\d+:\s+)warning:\s/i.test(content)) {
           return { type: 'warning', content };
-        if (/(?:^(?:[\w-]+:\s+)?|:\d+:\s+)(?:fatal )?error:\s/i.test(content))
+        }
+        if (/(?:^(?:[\w-]+:\s+)?|:\d+:\s+)(?:fatal )?error:\s/i.test(content)) {
           return { type: 'error', content };
+        }
         return null;
       })
       .filter(Boolean) as { type: 'warning' | 'error'; content: string }[];
@@ -266,12 +268,14 @@ export async function executeXcodeBuildCommand(
       });
     });
 
-    // Include all stderr lines as errors
+    // Include stderr lines, classifying warnings vs errors
     if (result.error) {
       result.error.split('\n').forEach((content) => {
-        if (content.trim()) {
-          buildMessages.push({ type: 'text', text: `❌ [stderr] ${content}` });
-        }
+        const trimmed = content.trim();
+        if (!trimmed) return;
+        const isWarning = /\bWARNING\b/i.test(trimmed);
+        const prefix = isWarning ? '⚠️ [stderr]' : '❌ [stderr]';
+        buildMessages.push({ type: 'text', text: `${prefix} ${content}` });
       });
     }