refactor: migrate simulator and simulator-management tools to event-based handler contract

Author: cameroncooke

src/mcp/tools/simulator-management/__tests__/erase_sims.test.ts

@@ -1,41 +1,69 @@
 import { describe, it, expect } from 'vitest';
-import * as z from 'zod';
 import { schema, erase_simsLogic } from '../erase_sims.ts';
 import { createMockExecutor } from '../../../../test-utils/mock-executors.ts';
+import { allText, createMockToolHandlerContext } from '../../../../test-utils/test-helpers.ts';
+
+const runLogic = async (logic: () => Promise<unknown>) => {
+  const { result, run } = createMockToolHandlerContext();
+  const response = await run(logic);
+
+  if (
+    response &&
+    typeof response === 'object' &&
+    'content' in (response as Record<string, unknown>)
+  ) {
+    return response as {
+      content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
+      isError?: boolean;
+      nextStepParams?: unknown;
+    };
+  }
+
+  const text = result.text();
+  const textContent = text.length > 0 ? [{ type: 'text' as const, text }] : [];
+  const imageContent = result.attachments.map((attachment) => ({
+    type: 'image' as const,
+    data: attachment.data,
+    mimeType: attachment.mimeType,
+  }));
+
+  return {
+    content: [...textContent, ...imageContent],
+    isError: result.isError() ? true : undefined,
+    nextStepParams: result.nextStepParams,
+    attachments: result.attachments,
+    text,
+  };
+};
 
 describe('erase_sims tool (single simulator)', () => {
-  describe('Schema Validation', () => {
-    it('should validate schema fields (shape only)', () => {
-      const schemaObj = z.object(schema);
-      expect(schemaObj.safeParse({ shutdownFirst: true }).success).toBe(true);
-      expect(schemaObj.safeParse({}).success).toBe(true);
+  describe('Plugin Structure', () => {
+    it('should expose schema', () => {
+      expect(schema).toBeDefined();
     });
   });
 
   describe('Single mode', () => {
     it('erases a simulator successfully', async () => {
       const mock = createMockExecutor({ success: true, output: 'OK' });
-      const res = await erase_simsLogic({ simulatorId: 'UD1' }, mock);
-      expect(res).toEqual({
-        content: [{ type: 'text', text: 'Successfully erased simulator UD1' }],
-      });
+      const res = await runLogic(() => erase_simsLogic({ simulatorId: 'UD1' }, mock));
+      expect(res.isError).toBeFalsy();
     });
 
     it('returns failure when erase fails', async () => {
       const mock = createMockExecutor({ success: false, error: 'Booted device' });
-      const res = await erase_simsLogic({ simulatorId: 'UD1' }, mock);
-      expect(res).toEqual({
-        content: [{ type: 'text', text: 'Failed to erase simulator: Booted device' }],
-      });
+      const res = await runLogic(() => erase_simsLogic({ simulatorId: 'UD1' }, mock));
+      expect(res.isError).toBe(true);
     });
 
     it('adds tool hint when booted error occurs without shutdownFirst', async () => {
       const bootedError =
         'An error was encountered processing the command (domain=com.apple.CoreSimulator.SimError, code=405):\nUnable to erase contents and settings in current state: Booted\n';
       const mock = createMockExecutor({ success: false, error: bootedError });
-      const res = await erase_simsLogic({ simulatorId: 'UD1' }, mock);
-      expect((res.content?.[1] as any).text).toContain('Tool hint');
-      expect((res.content?.[1] as any).text).toContain('shutdownFirst: true');
+      const res = await runLogic(() => erase_simsLogic({ simulatorId: 'UD1' }, mock));
+      const text = allText(res);
+      expect(text).toContain('shutdownFirst: true');
+      expect(res.isError).toBe(true);
     });
 
     it('performs shutdown first when shutdownFirst=true', async () => {
@@ -44,14 +72,14 @@ describe('erase_sims tool (single simulator)', () => {
         calls.push(cmd);
         return { success: true, output: 'OK', error: '', process: { pid: 1 } as any };
       };
-      const res = await erase_simsLogic({ simulatorId: 'UD1', shutdownFirst: true }, exec as any);
+      const res = await runLogic(() =>
+        erase_simsLogic({ simulatorId: 'UD1', shutdownFirst: true }, exec as any),
+      );
       expect(calls).toEqual([
         ['xcrun', 'simctl', 'shutdown', 'UD1'],
         ['xcrun', 'simctl', 'erase', 'UD1'],
       ]);
-      expect(res).toEqual({
-        content: [{ type: 'text', text: 'Successfully erased simulator UD1' }],
-      });
+      expect(res.isError).toBeFalsy();
     });
   });
 });

src/mcp/tools/simulator-management/__tests__/reset_sim_location.test.ts

@@ -2,6 +2,40 @@ import { describe, it, expect } from 'vitest';
 import * as z from 'zod';
 import { schema, reset_sim_locationLogic } from '../reset_sim_location.ts';
 import { createMockExecutor } from '../../../../test-utils/mock-executors.ts';
+import { createMockToolHandlerContext } from '../../../../test-utils/test-helpers.ts';
+
+const runLogic = async (logic: () => Promise<unknown>) => {
+  const { result, run } = createMockToolHandlerContext();
+  const response = await run(logic);
+
+  if (
+    response &&
+    typeof response === 'object' &&
+    'content' in (response as Record<string, unknown>)
+  ) {
+    return response as {
+      content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
+      isError?: boolean;
+      nextStepParams?: unknown;
+    };
+  }
+
+  const text = result.text();
+  const textContent = text.length > 0 ? [{ type: 'text' as const, text }] : [];
+  const imageContent = result.attachments.map((attachment) => ({
+    type: 'image' as const,
+    data: attachment.data,
+    mimeType: attachment.mimeType,
+  }));
+
+  return {
+    content: [...textContent, ...imageContent],
+    isError: result.isError() ? true : undefined,
+    nextStepParams: result.nextStepParams,
+    attachments: result.attachments,
+    text,
+  };
+};
 
 describe('reset_sim_location plugin', () => {
   describe('Schema Validation', () => {
@@ -23,21 +57,16 @@ describe('reset_sim_location plugin', () => {
         output: 'Location reset successfully',
       });
 
-      const result = await reset_sim_locationLogic(
-        {
-          simulatorId: 'test-uuid-123',
-        },
-        mockExecutor,
-      );
-
-      expect(result).toEqual({
-        content: [
+      const result = await runLogic(() =>
+        reset_sim_locationLogic(
           {
-            type: 'text',
-            text: 'Successfully reset simulator test-uuid-123 location.',
+            simulatorId: 'test-uuid-123',
           },
-        ],
-      });
+          mockExecutor,
+        ),
+      );
+
+      expect(result.isError).toBeFalsy();
     });
 
     it('should handle command failure', async () => {
@@ -46,41 +75,31 @@ describe('reset_sim_location plugin', () => {
         error: 'Command failed',
       });
 
-      const result = await reset_sim_locationLogic(
-        {
-          simulatorId: 'test-uuid-123',
-        },
-        mockExecutor,
-      );
-
-      expect(result).toEqual({
-        content: [
+      const result = await runLogic(() =>
+        reset_sim_locationLogic(
           {
-            type: 'text',
-            text: 'Failed to reset simulator location: Command failed',
+            simulatorId: 'test-uuid-123',
           },
-        ],
-      });
+          mockExecutor,
+        ),
+      );
+
+      expect(result.isError).toBe(true);
     });
 
     it('should handle exception during execution', async () => {
       const mockExecutor = createMockExecutor(new Error('Network error'));
 
-      const result = await reset_sim_locationLogic(
-        {
-          simulatorId: 'test-uuid-123',
-        },
-        mockExecutor,
-      );
-
-      expect(result).toEqual({
-        content: [
+      const result = await runLogic(() =>
+        reset_sim_locationLogic(
           {
-            type: 'text',
-            text: 'Failed to reset simulator location: Network error',
+            simulatorId: 'test-uuid-123',
           },
-        ],
-      });
+          mockExecutor,
+        ),
+      );
+
+      expect(result.isError).toBe(true);
     });
 
     it('should call correct command', async () => {
@@ -92,18 +111,19 @@ describe('reset_sim_location plugin', () => {
         output: 'Location reset successfully',
       });
 
-      // Create a wrapper to capture the command arguments
       const capturingExecutor = async (command: string[], logPrefix?: string) => {
         capturedCommand = command;
         capturedLogPrefix = logPrefix;
         return mockExecutor(command, logPrefix);
       };
 
-      await reset_sim_locationLogic(
-        {
-          simulatorId: 'test-uuid-123',
-        },
-        capturingExecutor,
+      await runLogic(() =>
+        reset_sim_locationLogic(
+          {
+            simulatorId: 'test-uuid-123',
+          },
+          capturingExecutor,
+        ),
       );
 
       expect(capturedCommand).toEqual(['xcrun', 'simctl', 'location', 'test-uuid-123', 'clear']);