agent-device 0.3.4 → 0.4.0

package/src/platforms/ios/__tests__/runner-client.test.ts

@@ -0,0 +1,113 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import type { DeviceInfo } from '../../../utils/device.ts';
+import {
+  assertSafeDerivedCleanup,
+  resolveRunnerBuildDestination,
+  resolveRunnerDestination,
+  resolveRunnerMaxConcurrentDestinationsFlag,
+  resolveRunnerSigningBuildSettings,
+} from '../runner-client.ts';
+
+const iosSimulator: DeviceInfo = {
+  platform: 'ios',
+  id: 'sim-1',
+  name: 'iPhone Simulator',
+  kind: 'simulator',
+  booted: true,
+};
+
+const iosDevice: DeviceInfo = {
+  platform: 'ios',
+  id: '00008110-000E12341234002E',
+  name: 'iPhone',
+  kind: 'device',
+  booted: true,
+};
+
+test('resolveRunnerDestination uses simulator destination for simulators', () => {
+  assert.equal(resolveRunnerDestination(iosSimulator), 'platform=iOS Simulator,id=sim-1');
+});
+
+test('resolveRunnerDestination uses device destination for physical devices', () => {
+  assert.equal(
+    resolveRunnerDestination(iosDevice),
+    'platform=iOS,id=00008110-000E12341234002E',
+  );
+});
+
+test('resolveRunnerBuildDestination uses generic iOS destination for physical devices', () => {
+  assert.equal(resolveRunnerBuildDestination(iosDevice), 'generic/platform=iOS');
+});
+
+test('resolveRunnerMaxConcurrentDestinationsFlag uses simulator flag for simulators', () => {
+  assert.equal(
+    resolveRunnerMaxConcurrentDestinationsFlag(iosSimulator),
+    '-maximum-concurrent-test-simulator-destinations',
+  );
+});
+
+test('resolveRunnerMaxConcurrentDestinationsFlag uses device flag for physical devices', () => {
+  assert.equal(
+    resolveRunnerMaxConcurrentDestinationsFlag(iosDevice),
+    '-maximum-concurrent-test-device-destinations',
+  );
+});
+
+test('resolveRunnerSigningBuildSettings returns empty args without env overrides', () => {
+  assert.deepEqual(resolveRunnerSigningBuildSettings({}), []);
+});
+
+test('resolveRunnerSigningBuildSettings enables automatic signing for device builds without forcing identity', () => {
+  assert.deepEqual(resolveRunnerSigningBuildSettings({}, true), [
+    'CODE_SIGN_STYLE=Automatic',
+  ]);
+});
+
+test('resolveRunnerSigningBuildSettings ignores device signing overrides for simulator builds', () => {
+  assert.deepEqual(resolveRunnerSigningBuildSettings({
+    AGENT_DEVICE_IOS_TEAM_ID: 'ABCDE12345',
+    AGENT_DEVICE_IOS_SIGNING_IDENTITY: 'Apple Development',
+    AGENT_DEVICE_IOS_PROVISIONING_PROFILE: 'My Profile',
+  }, false), []);
+});
+
+test('resolveRunnerSigningBuildSettings applies optional overrides when provided', () => {
+  const settings = resolveRunnerSigningBuildSettings({
+    AGENT_DEVICE_IOS_TEAM_ID: 'ABCDE12345',
+    AGENT_DEVICE_IOS_SIGNING_IDENTITY: 'Apple Development',
+    AGENT_DEVICE_IOS_PROVISIONING_PROFILE: 'My Profile',
+  }, true);
+  assert.deepEqual(settings, [
+    'CODE_SIGN_STYLE=Automatic',
+    'DEVELOPMENT_TEAM=ABCDE12345',
+    'CODE_SIGN_IDENTITY=Apple Development',
+    'PROVISIONING_PROFILE_SPECIFIER=My Profile',
+  ]);
+});
+
+test('assertSafeDerivedCleanup allows cleaning when no override is set', () => {
+  assert.doesNotThrow(() => {
+    assertSafeDerivedCleanup('/tmp/derived', {});
+  });
+});
+
+test('assertSafeDerivedCleanup rejects cleaning override path by default', () => {
+  assert.throws(
+    () => {
+      assertSafeDerivedCleanup('/tmp/custom', {
+        AGENT_DEVICE_IOS_RUNNER_DERIVED_PATH: '/tmp/custom',
+      });
+    },
+    /Refusing to clean AGENT_DEVICE_IOS_RUNNER_DERIVED_PATH automatically/,
+  );
+});
+
+test('assertSafeDerivedCleanup allows cleaning override path with explicit opt-in', () => {
+  assert.doesNotThrow(() => {
+    assertSafeDerivedCleanup('/tmp/custom', {
+      AGENT_DEVICE_IOS_RUNNER_DERIVED_PATH: '/tmp/custom',
+      AGENT_DEVICE_IOS_ALLOW_OVERRIDE_DERIVED_CLEAN: '1',
+    });
+  });
+});

package/src/platforms/ios/devices.ts

@@ -1,3 +1,6 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { runCmd, whichCmd } from '../../utils/exec.ts';
 import { AppError } from '../../utils/errors.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
@@ -38,26 +41,45 @@ export async function listIosDevices(): Promise<DeviceInfo[]> {
     throw new AppError('COMMAND_FAILED', 'Failed to parse simctl devices JSON', undefined, err);
   }
 
-  const devicectlAvailable = await whichCmd('xcrun');
-  if (devicectlAvailable) {
-    try {
-      const result = await runCmd('xcrun', ['devicectl', 'list', 'devices', '--json']);
-      const payload = JSON.parse(result.stdout as string) as {
-        devices: { identifier: string; name: string; platform: string }[];
+  let jsonPath: string | null = null;
+  try {
+    jsonPath = path.join(
+      os.tmpdir(),
+      `agent-device-devicectl-${process.pid}-${Date.now()}.json`,
+    );
+    await runCmd('xcrun', ['devicectl', 'list', 'devices', '--json-output', jsonPath]);
+    const jsonText = await fs.readFile(jsonPath, 'utf8');
+    const payload = JSON.parse(jsonText) as {
+      result?: {
+        devices?: Array<{
+          identifier?: string;
+          name?: string;
+          hardwareProperties?: { platform?: string; udid?: string };
+          deviceProperties?: { name?: string };
+          connectionProperties?: { tunnelState?: string };
+        }>;
       };
-      for (const device of payload.devices ?? []) {
-        if (device.platform?.toLowerCase().includes('ios')) {
-          devices.push({
-            platform: 'ios',
-            id: device.identifier,
-            name: device.name,
-            kind: 'device',
-            booted: true,
-          });
-        }
+    };
+    for (const device of payload.result?.devices ?? []) {
+      const platform = device.hardwareProperties?.platform ?? '';
+      if (platform.toLowerCase().includes('ios')) {
+        const id = device.hardwareProperties?.udid ?? device.identifier ?? '';
+        const name = device.name ?? device.deviceProperties?.name ?? id;
+        if (!id) continue;
+        devices.push({
+          platform: 'ios',
+          id,
+          name,
+          kind: 'device',
+          booted: true,
+        });
       }
-    } catch {
-      // Ignore devicectl failures; simulators are still supported.
+    }
+  } catch {
+    // Ignore devicectl failures; simulators are still supported.
+  } finally {
+    if (jsonPath) {
+      await fs.rm(jsonPath, { force: true }).catch(() => {});
     }
   }
 

package/src/platforms/ios/index.ts

@@ -3,6 +3,7 @@ import type { ExecResult } from '../../utils/exec.ts';
 import { AppError } from '../../utils/errors.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
 import { Deadline, isEnvTruthy, retryWithPolicy, TIMEOUT_PROFILES, type RetryTelemetryEvent } from '../../utils/retry.ts';
+import { isDeepLinkTarget } from '../../core/open-target.ts';
 import { bootFailureHint, classifyBootFailure } from '../boot-diagnostics.ts';
 
 const ALIASES: Record<string, string> = {
@@ -14,6 +15,16 @@ const IOS_BOOT_TIMEOUT_MS = resolveTimeoutMs(
   TIMEOUT_PROFILES.ios_boot.totalMs,
   5_000,
 );
+const IOS_SIMCTL_LIST_TIMEOUT_MS = resolveTimeoutMs(
+  process.env.AGENT_DEVICE_IOS_SIMCTL_LIST_TIMEOUT_MS,
+  TIMEOUT_PROFILES.ios_boot.operationMs,
+  1_000,
+);
+const IOS_APP_LAUNCH_TIMEOUT_MS = resolveTimeoutMs(
+  process.env.AGENT_DEVICE_IOS_APP_LAUNCH_TIMEOUT_MS,
+  30_000,
+  5_000,
+);
 const RETRY_LOGS_ENABLED = isEnvTruthy(process.env.AGENT_DEVICE_RETRY_LOGS);
 
 export async function resolveIosApp(device: DeviceInfo, app: string): Promise<string> {
@@ -35,12 +46,54 @@ export async function resolveIosApp(device: DeviceInfo, app: string): Promise<st
   throw new AppError('APP_NOT_INSTALLED', `No app found matching "${app}"`);
 }
 
-export async function openIosApp(device: DeviceInfo, app: string): Promise<void> {
-  const bundleId = await resolveIosApp(device, app);
+export async function openIosApp(
+  device: DeviceInfo,
+  app: string,
+  options?: { appBundleId?: string },
+): Promise<void> {
+  const deepLinkTarget = app.trim();
+  if (isDeepLinkTarget(deepLinkTarget)) {
+    if (device.kind !== 'simulator') {
+      throw new AppError('UNSUPPORTED_OPERATION', 'Deep link open is only supported on iOS simulators');
+    }
+    await ensureBootedSimulator(device);
+    await runCmd('open', ['-a', 'Simulator'], { allowFailure: true });
+    await runCmd('xcrun', ['simctl', 'openurl', device.id, deepLinkTarget]);
+    return;
+  }
+  const bundleId = options?.appBundleId ?? (await resolveIosApp(device, app));
   if (device.kind === 'simulator') {
     await ensureBootedSimulator(device);
     await runCmd('open', ['-a', 'Simulator'], { allowFailure: true });
-    await runCmd('xcrun', ['simctl', 'launch', device.id, bundleId]);
+    const launchDeadline = Deadline.fromTimeoutMs(IOS_APP_LAUNCH_TIMEOUT_MS);
+    await retryWithPolicy(
+      async ({ deadline: attemptDeadline }) => {
+        if (attemptDeadline?.isExpired()) {
+          throw new AppError('COMMAND_FAILED', 'App launch deadline exceeded', {
+            timeoutMs: IOS_APP_LAUNCH_TIMEOUT_MS,
+          });
+        }
+        const result = await runCmd('xcrun', ['simctl', 'launch', device.id, bundleId], {
+          allowFailure: true,
+        });
+        if (result.exitCode === 0) return;
+        throw new AppError('COMMAND_FAILED', `xcrun exited with code ${result.exitCode}`, {
+          cmd: 'xcrun',
+          args: ['simctl', 'launch', device.id, bundleId],
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: result.exitCode,
+        });
+      },
+      {
+        maxAttempts: 30,
+        baseDelayMs: 1_000,
+        maxDelayMs: 5_000,
+        jitter: 0.2,
+        shouldRetry: isTransientSimulatorLaunchFailure,
+      },
+      { deadline: launchDeadline },
+    );
     return;
   }
   await runCmd('xcrun', [
@@ -196,7 +249,7 @@ function ensureSimulator(device: DeviceInfo, command: string): void {
   if (device.kind !== 'simulator') {
     throw new AppError(
       'UNSUPPORTED_OPERATION',
-      `${command} is only supported on iOS simulators in v1`,
+      `${command} is only supported on iOS simulators`,
     );
   }
 }
@@ -208,6 +261,18 @@ function parseSettingState(state: string): boolean {
   throw new AppError('INVALID_ARGS', `Invalid setting state: ${state}`);
 }
 
+function isTransientSimulatorLaunchFailure(error: unknown): boolean {
+  if (!(error instanceof AppError)) return false;
+  if (error.code !== 'COMMAND_FAILED') return false;
+  const details = (error.details ?? {}) as { exitCode?: number; stderr?: unknown };
+  if (details.exitCode !== 4) return false;
+  const stderr = String(details.stderr ?? '').toLowerCase();
+  return (
+    stderr.includes('fbsopenapplicationserviceerrordomain') &&
+    stderr.includes('the request to open')
+  );
+}
+
 export async function listSimulatorApps(
   device: DeviceInfo,
 ): Promise<{ bundleId: string; name: string }[]> {
@@ -365,7 +430,7 @@ export async function ensureBootedSimulator(device: DeviceInfo): Promise<void> {
 async function getSimulatorState(udid: string): Promise<string | null> {
   const result = await runCmd('xcrun', ['simctl', 'list', 'devices', '-j'], {
     allowFailure: true,
-    timeoutMs: TIMEOUT_PROFILES.ios_boot.operationMs,
+    timeoutMs: IOS_SIMCTL_LIST_TIMEOUT_MS,
   });
   if (result.exitCode !== 0) return null;
   try {