fix(setup): Tolerate optional discovery failures

Allow setup to continue when optional simulator or device discovery
fails instead of aborting the wizard.

Catch rejecting simulator and xctrace lookups, and treat injected
filesystem temp-path failures the same way so optional defaults can
still be skipped during setup.

Author: cameroncooke

src/cli/commands/__tests__/setup.test.ts

@@ -741,6 +741,156 @@ sessionDefaults:
     expect(parsed.sessionDefaults?.simulatorName).toBeUndefined();
   });
 
+  it('continues setup with no default device when xctrace spawn fails', async () => {
+    const { fs, getStoredConfig } = createSetupFs();
+
+    const executor: CommandExecutor = async (command) => {
+      if (command[0] === 'xcrun' && command[1] === 'devicectl') {
+        throw new Error('devicectl unavailable');
+      }
+
+      if (command[0] === 'xcrun' && command[1] === 'xctrace') {
+        throw new Error('xctrace spawn failed');
+      }
+
+      if (command.includes('--json')) {
+        return createMockCommandResponse({
+          success: true,
+          output: JSON.stringify({
+            devices: {
+              'iOS 17.0': [
+                {
+                  name: 'iPhone 15',
+                  udid: 'SIM-1',
+                  state: 'Shutdown',
+                  isAvailable: true,
+                },
+              ],
+            },
+          }),
+        });
+      }
+
+      return createMockCommandResponse({
+        success: true,
+        output: `Information about workspace "App":\n    Schemes:\n        App`,
+      });
+    };
+
+    const prompter: Prompter = {
+      selectOne: async <T>(opts: { options: Array<{ value: T }> }) => opts.options[0].value,
+      selectMany: async <T>(opts: { options: Array<{ value: T }> }) => {
+        const loggingOption = opts.options.find((option) => option.value === ('logging' as T));
+        return loggingOption ? [loggingOption.value] : opts.options.map((option) => option.value);
+      },
+      confirm: async (opts: { defaultValue: boolean }) => opts.defaultValue,
+    };
+
+    await runSetupWizard({
+      cwd,
+      fs,
+      executor,
+      prompter,
+      quietOutput: true,
+    });
+
+    const parsed = parseYaml(getStoredConfig()) as {
+      sessionDefaults?: Record<string, unknown>;
+    };
+
+    expect(parsed.sessionDefaults?.deviceId).toBeUndefined();
+    expect(parsed.sessionDefaults?.simulatorId).toBeUndefined();
+    expect(parsed.sessionDefaults?.simulatorName).toBeUndefined();
+  });
+
+  it('continues setup with no default device when temp path creation fails', async () => {
+    const { fs, getStoredConfig } = createSetupFs();
+    fs.tmpdir = () => {
+      throw new Error('tmpdir unavailable');
+    };
+
+    const executor: CommandExecutor = async (command) => {
+      if (command[0] === 'xcrun' && command[1] === 'xctrace') {
+        throw new Error('xctrace spawn failed');
+      }
+
+      return createMockCommandResponse({
+        success: true,
+        output: `Information about workspace "App":\n    Schemes:\n        App`,
+      });
+    };
+
+    const prompter: Prompter = {
+      selectOne: async <T>(opts: { options: Array<{ value: T }> }) => opts.options[0].value,
+      selectMany: async <T>(opts: { options: Array<{ value: T }> }) => {
+        const loggingOption = opts.options.find((option) => option.value === ('logging' as T));
+        return loggingOption ? [loggingOption.value] : opts.options.map((option) => option.value);
+      },
+      confirm: async (opts: { defaultValue: boolean }) => opts.defaultValue,
+    };
+
+    await runSetupWizard({
+      cwd,
+      fs,
+      executor,
+      prompter,
+      quietOutput: true,
+    });
+
+    const parsed = parseYaml(getStoredConfig()) as {
+      sessionDefaults?: Record<string, unknown>;
+    };
+
+    expect(parsed.sessionDefaults?.deviceId).toBeUndefined();
+    expect(parsed.sessionDefaults?.simulatorId).toBeUndefined();
+    expect(parsed.sessionDefaults?.simulatorName).toBeUndefined();
+  });
+
+  it('continues setup with no default simulator when simulator discovery fails', async () => {
+    const { fs, getStoredConfig } = createSetupFs();
+
+    const executor: CommandExecutor = async (command) => {
+      if (command[0] === 'xcrun' && command[1] === 'devicectl') {
+        throw new Error('device lookup should not run for simulator-only workflows');
+      }
+
+      if (command[0] === 'xcrun' && command[1] === 'simctl') {
+        throw new Error('simctl unavailable');
+      }
+
+      return createMockCommandResponse({
+        success: true,
+        output: `Information about workspace "App":\n    Schemes:\n        App`,
+      });
+    };
+
+    const prompter: Prompter = {
+      selectOne: async <T>(opts: { options: Array<{ value: T }> }) => opts.options[0].value,
+      selectMany: async <T>(opts: { options: Array<{ value: T }> }) => {
+        const simulatorOption = opts.options.find((option) => option.value === ('simulator' as T));
+        return simulatorOption
+          ? [simulatorOption.value]
+          : opts.options.map((option) => option.value);
+      },
+      confirm: async (opts: { defaultValue: boolean }) => opts.defaultValue,
+    };
+
+    await runSetupWizard({
+      cwd,
+      fs,
+      executor,
+      prompter,
+      quietOutput: true,
+    });
+
+    const parsed = parseYaml(getStoredConfig()) as {
+      sessionDefaults?: Record<string, unknown>;
+    };
+
+    expect(parsed.sessionDefaults?.simulatorId).toBeUndefined();
+    expect(parsed.sessionDefaults?.simulatorName).toBeUndefined();
+  });
+
   it('continues setup with no default simulator when no simulators are available', async () => {
     const { fs, getStoredConfig } = createSetupFs();
 

src/cli/commands/setup.ts

@@ -379,7 +379,13 @@ async function selectSimulator(opts: {
     quietOutput: opts.quietOutput,
     startMessage: 'Loading simulators...',
     stopMessage: 'Simulators loaded.',
-    task: () => listSimulators(opts.executor),
+    task: async () => {
+      try {
+        return await listSimulators(opts.executor);
+      } catch {
+        return [];
+      }
+    },
   });
 
   const defaultIndex =
@@ -543,41 +549,52 @@ async function listAvailableDevices(
   fileSystem: FileSystemExecutor,
   executor: CommandExecutor,
 ): Promise<SetupDevice[]> {
-  const jsonPath = path.join(fileSystem.tmpdir(), `xcodebuildmcp-setup-devices-${Date.now()}.json`);
-
   try {
-    const result = await executor(
-      ['xcrun', 'devicectl', 'list', 'devices', '--json-output', jsonPath],
-      'List Devices (setup)',
-      false,
-      undefined,
+    const jsonPath = path.join(
+      fileSystem.tmpdir(),
+      `xcodebuildmcp-setup-devices-${Date.now()}.json`,
     );
 
-    if (result.success) {
-      const jsonContent = await fileSystem.readFile(jsonPath, 'utf8');
-      const devices = parseDeviceListResponse(JSON.parse(jsonContent));
-      if (devices.length > 0) {
-        return devices;
+    try {
+      const result = await executor(
+        ['xcrun', 'devicectl', 'list', 'devices', '--json-output', jsonPath],
+        'List Devices (setup)',
+        false,
+        undefined,
+      );
+
+      if (result.success) {
+        const jsonContent = await fileSystem.readFile(jsonPath, 'utf8');
+        const devices = parseDeviceListResponse(JSON.parse(jsonContent));
+        if (devices.length > 0) {
+          return devices;
+        }
       }
+    } catch {
+      // Fall back to xctrace below.
+    } finally {
+      await fileSystem.rm(jsonPath, { force: true }).catch(() => {});
     }
   } catch {
-    // Fall back to xctrace below.
-  } finally {
-    await fileSystem.rm(jsonPath, { force: true }).catch(() => {});
+    return [];
   }
 
-  const fallbackResult = await executor(
-    ['xcrun', 'xctrace', 'list', 'devices'],
-    'List Devices (setup fallback)',
-    false,
-    undefined,
-  );
+  try {
+    const fallbackResult = await executor(
+      ['xcrun', 'xctrace', 'list', 'devices'],
+      'List Devices (setup fallback)',
+      false,
+      undefined,
+    );
 
-  if (!fallbackResult.success) {
+    if (!fallbackResult.success) {
+      return [];
+    }
+
+    return parseXctraceDevices(fallbackResult.output);
+  } catch {
     return [];
   }
-
-  return parseXctraceDevices(fallbackResult.output);
 }
 
 function getDefaultDeviceIndex(devices: SetupDevice[], existingDeviceId?: string): number {