feat: add MCP integration snapshot test harness

Add mcp-harness.ts that combines the MCP test harness (real server
with in-memory transport and mocked executors) with the snapshot
normalization and fixture comparison pipeline.

Initial test scenarios cover session management (show/set defaults)
and error paths (missing required params). The harness can be
extended with additional tool scenarios.

Author: cameroncooke

src/snapshot-tests/__fixtures__/mcp-integration/build-sim--missing-params.txt

@@ -0,0 +1,3 @@
+
+❌ Missing required session defaults: Provide a project or workspace
+Set with: session-set-defaults { "projectPath": "..." } OR session-set-defaults { "workspacePath": "..." }

src/snapshot-tests/__fixtures__/mcp-integration/session-set-defaults--scheme.txt

@@ -0,0 +1,23 @@
+
+⚙️ Set Defaults
+
+   Scheme: CalculatorApp
+   Profile: (default)
+
+✅ Session defaults updated (default profile)
+  ├ projectPath: (not set)
+  ├ workspacePath: (not set)
+  ├ scheme: CalculatorApp
+  ├ configuration: (not set)
+  ├ simulatorName: (not set)
+  ├ simulatorId: (not set)
+  ├ simulatorPlatform: (not set)
+  ├ deviceId: (not set)
+  ├ useLatestOS: (not set)
+  ├ arch: (not set)
+  ├ suppressWarnings: (not set)
+  ├ derivedDataPath: (not set)
+  ├ preferXcodebuild: (not set)
+  ├ platform: (not set)
+  ├ bundleId: (not set)
+  └ env: (not set)

src/snapshot-tests/__fixtures__/mcp-integration/session-show-defaults--empty.txt

@@ -0,0 +1,20 @@
+
+⚙️ Show Defaults
+
+📁 (default)
+  ├ projectPath: (not set)
+  ├ workspacePath: (not set)
+  ├ scheme: (not set)
+  ├ configuration: (not set)
+  ├ simulatorName: (not set)
+  ├ simulatorId: (not set)
+  ├ simulatorPlatform: (not set)
+  ├ deviceId: (not set)
+  ├ useLatestOS: (not set)
+  ├ arch: (not set)
+  ├ suppressWarnings: (not set)
+  ├ derivedDataPath: (not set)
+  ├ preferXcodebuild: (not set)
+  ├ platform: (not set)
+  ├ bundleId: (not set)
+  └ env: (not set)

src/snapshot-tests/__tests__/mcp-integration.snapshot.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { createMcpSnapshotHarness, type McpSnapshotHarness } from '../mcp-harness.ts';
+import { expectMatchesFixture } from '../fixture-io.ts';
+
+let harness: McpSnapshotHarness;
+
+beforeAll(async () => {
+  harness = await createMcpSnapshotHarness({
+    commandResponses: {
+      'xcodebuild -version': {
+        success: true,
+        output: 'Xcode 16.0\nBuild version 16A242d',
+      },
+      'xcodebuild -showBuildSettings': {
+        success: true,
+        output:
+          'Build settings for action build and target "CalculatorApp":\n' +
+          '    PRODUCT_BUNDLE_IDENTIFIER = io.sentry.calculatorapp\n' +
+          '    PRODUCT_NAME = CalculatorApp\n',
+      },
+      'simctl list devices': {
+        success: true,
+        output: JSON.stringify({
+          devices: {
+            'com.apple.CoreSimulator.SimRuntime.iOS-18-0': [
+              {
+                name: 'iPhone 16 Pro',
+                udid: 'AAAAAAAA-1111-2222-3333-444444444444',
+                state: 'Booted',
+                isAvailable: true,
+              },
+              {
+                name: 'iPhone 16',
+                udid: 'BBBBBBBB-1111-2222-3333-444444444444',
+                state: 'Shutdown',
+                isAvailable: true,
+              },
+            ],
+          },
+        }),
+      },
+      xcodebuild: { success: true, output: '** BUILD SUCCEEDED **' },
+    },
+  });
+}, 30_000);
+
+afterAll(async () => {
+  await harness.cleanup();
+});
+
+beforeEach(() => {
+  harness.resetCapturedCommands();
+});
+
+describe('MCP Integration Snapshots', () => {
+  describe('session-management', () => {
+    it('session_show_defaults -- empty', async () => {
+      await harness.client.callTool({
+        name: 'session_clear_defaults',
+        arguments: { all: true },
+      });
+      const { text, isError } = await harness.callTool('session_show_defaults', {});
+      expect(isError).toBe(false);
+      expectMatchesFixture(text, __filename, 'session-show-defaults--empty');
+    });
+
+    it('session_set_defaults -- set scheme', async () => {
+      await harness.client.callTool({
+        name: 'session_clear_defaults',
+        arguments: { all: true },
+      });
+      const { text, isError } = await harness.callTool('session_set_defaults', {
+        scheme: 'CalculatorApp',
+      });
+      expect(isError).toBe(false);
+      expectMatchesFixture(text, __filename, 'session-set-defaults--scheme');
+    });
+  });
+
+  describe('error-paths', () => {
+    it('build_sim -- missing required params', async () => {
+      const { text, isError } = await harness.callTool('build_sim', {});
+      expect(isError).toBe(true);
+      expectMatchesFixture(text, __filename, 'build-sim--missing-params');
+    });
+  });
+});

src/snapshot-tests/mcp-harness.ts

@@ -0,0 +1,47 @@
+import {
+  createMcpTestHarness,
+  type McpTestHarness,
+  type McpTestHarnessOptions,
+} from '../smoke-tests/mcp-test-harness.ts';
+import { extractText } from '../smoke-tests/test-helpers.ts';
+import { normalizeSnapshotOutput } from './normalize.ts';
+
+export interface McpSnapshotHarness {
+  callTool(name: string, args: Record<string, unknown>): Promise<McpSnapshotResult>;
+  client: McpTestHarness['client'];
+  capturedCommands: McpTestHarness['capturedCommands'];
+  resetCapturedCommands(): void;
+  cleanup(): Promise<void>;
+}
+
+export interface McpSnapshotResult {
+  text: string;
+  rawText: string;
+  isError: boolean;
+}
+
+export async function createMcpSnapshotHarness(
+  opts?: McpTestHarnessOptions,
+): Promise<McpSnapshotHarness> {
+  const harness = await createMcpTestHarness(opts);
+
+  async function callTool(
+    name: string,
+    args: Record<string, unknown>,
+  ): Promise<McpSnapshotResult> {
+    const result = await harness.client.callTool({ name, arguments: args });
+    const rawText = extractText(result) + '\n';
+    const text = normalizeSnapshotOutput(rawText);
+    const isError = (result as { isError?: boolean }).isError ?? false;
+
+    return { text, rawText, isError };
+  }
+
+  return {
+    callTool,
+    client: harness.client,
+    capturedCommands: harness.capturedCommands,
+    resetCapturedCommands: harness.resetCapturedCommands,
+    cleanup: harness.cleanup,
+  };
+}