agent-device 0.3.5 → 0.4.1

package/src/daemon-client.ts

@@ -6,6 +6,7 @@ import { AppError } from './utils/errors.ts';
 import type { CommandFlags } from './core/dispatch.ts';
 import { runCmdDetached } from './utils/exec.ts';
 import { findProjectRoot, readVersion } from './utils/version.ts';
+import { stopProcessForTakeover } from './utils/process-identity.ts';
 
 export type DaemonRequest = {
   token: string;
@@ -19,12 +20,20 @@ export type DaemonResponse =
   | { ok: true; data?: Record<string, unknown> }
   | { ok: false; error: { code: string; message: string; details?: Record<string, unknown> } };
 
-type DaemonInfo = { port: number; token: string; pid: number; version?: string };
+type DaemonInfo = {
+  port: number;
+  token: string;
+  pid: number;
+  version?: string;
+  processStartTime?: string;
+};
 
 const baseDir = path.join(os.homedir(), '.agent-device');
 const infoPath = path.join(baseDir, 'daemon.json');
-const REQUEST_TIMEOUT_MS = resolveRequestTimeoutMs();
+const REQUEST_TIMEOUT_MS = resolveDaemonRequestTimeoutMs();
 const DAEMON_STARTUP_TIMEOUT_MS = 5000;
+const DAEMON_TAKEOVER_TERM_TIMEOUT_MS = 3000;
+const DAEMON_TAKEOVER_KILL_TIMEOUT_MS = 1000;
 
 export async function sendToDaemon(req: Omit<DaemonRequest, 'token'>): Promise<DaemonResponse> {
   const info = await ensureDaemon();
@@ -35,8 +44,10 @@ export async function sendToDaemon(req: Omit<DaemonRequest, 'token'>): Promise<D
 async function ensureDaemon(): Promise<DaemonInfo> {
   const existing = readDaemonInfo();
   const localVersion = readVersion();
-  if (existing && existing.version === localVersion && (await canConnect(existing))) return existing;
-  if (existing && (existing.version !== localVersion || !(await canConnect(existing)))) {
+  const existingReachable = existing ? await canConnect(existing) : false;
+  if (existing && existing.version === localVersion && existingReachable) return existing;
+  if (existing && (existing.version !== localVersion || !existingReachable)) {
+    await stopDaemonProcessForTakeover(existing);
     removeDaemonInfo();
   }
 
@@ -55,19 +66,34 @@ async function ensureDaemon(): Promise<DaemonInfo> {
   });
 }
 
+async function stopDaemonProcessForTakeover(info: DaemonInfo): Promise<void> {
+  await stopProcessForTakeover(info.pid, {
+    termTimeoutMs: DAEMON_TAKEOVER_TERM_TIMEOUT_MS,
+    killTimeoutMs: DAEMON_TAKEOVER_KILL_TIMEOUT_MS,
+    expectedStartTime: info.processStartTime,
+  });
+}
+
 function readDaemonInfo(): DaemonInfo | null {
   if (!fs.existsSync(infoPath)) return null;
   try {
     const data = JSON.parse(fs.readFileSync(infoPath, 'utf8')) as DaemonInfo;
     if (!data.port || !data.token) return null;
-    return data;
+    return {
+      ...data,
+      pid: Number.isInteger(data.pid) && data.pid > 0 ? data.pid : 0,
+    };
   } catch {
     return null;
   }
 }
 
 function removeDaemonInfo(): void {
-  if (fs.existsSync(infoPath)) fs.unlinkSync(infoPath);
+  try {
+    if (fs.existsSync(infoPath)) fs.unlinkSync(infoPath);
+  } catch {
+    // Best-effort cleanup only; daemon can still overwrite this file on startup.
+  }
 }
 
 async function canConnect(info: DaemonInfo): Promise<boolean> {
@@ -87,11 +113,14 @@ async function startDaemon(): Promise<void> {
   const distPath = path.join(root, 'dist', 'src', 'daemon.js');
   const srcPath = path.join(root, 'src', 'daemon.ts');
 
-  const useDist = fs.existsSync(distPath);
-  if (!useDist && !fs.existsSync(srcPath)) {
+  const hasDist = fs.existsSync(distPath);
+  const hasSrc = fs.existsSync(srcPath);
+  if (!hasDist && !hasSrc) {
     throw new AppError('COMMAND_FAILED', 'Daemon entry not found', { distPath, srcPath });
   }
-  const args = useDist ? [distPath] : ['--experimental-strip-types', srcPath];
+  const runningFromSource = process.execArgv.includes('--experimental-strip-types');
+  const useSrc = runningFromSource ? hasSrc : !hasDist && hasSrc;
+  const args = useSrc ? ['--experimental-strip-types', srcPath] : [distPath];
 
   runCmdDetached(process.execPath, args);
 }
@@ -134,10 +163,10 @@ async function sendRequest(info: DaemonInfo, req: DaemonRequest): Promise<Daemon
   });
 }
 
-function resolveRequestTimeoutMs(): number {
-  const raw = process.env.AGENT_DEVICE_DAEMON_TIMEOUT_MS;
-  if (!raw) return 60000;
+export function resolveDaemonRequestTimeoutMs(raw: string | undefined = process.env.AGENT_DEVICE_DAEMON_TIMEOUT_MS): number {
+  // iOS physical-device runner startup/build can exceed 60s, so use a safer default for daemon RPCs.
+  if (!raw) return 180000;
   const parsed = Number(raw);
-  if (!Number.isFinite(parsed)) return 60000;
+  if (!Number.isFinite(parsed)) return 180000;
   return Math.max(1000, Math.floor(parsed));
 }

package/src/daemon.ts

@@ -7,7 +7,7 @@ import { dispatchCommand, type CommandFlags } from './core/dispatch.ts';
 import { isCommandSupportedOnDevice } from './core/capabilities.ts';
 import { asAppError, AppError } from './utils/errors.ts';
 import { readVersion } from './utils/version.ts';
-import { stopIosRunnerSession } from './platforms/ios/runner-client.ts';
+import { stopAllIosRunnerSessions } from './platforms/ios/runner-client.ts';
 import type { DaemonRequest, DaemonResponse } from './daemon/types.ts';
 import { SessionStore } from './daemon/session-store.ts';
 import { contextFromFlags as contextFromFlagsWithLog, type DaemonCommandContext } from './daemon/context.ts';
@@ -18,9 +18,14 @@ import { handleRecordTraceCommands } from './daemon/handlers/record-trace.ts';
 import { handleInteractionCommands } from './daemon/handlers/interaction.ts';
 import { assertSessionSelectorMatches } from './daemon/session-selector.ts';
 import { resolveEffectiveSessionName } from './daemon/session-routing.ts';
+import {
+  isAgentDeviceDaemonProcess,
+  readProcessStartTime,
+} from './utils/process-identity.ts';
 
 const baseDir = path.join(os.homedir(), '.agent-device');
 const infoPath = path.join(baseDir, 'daemon.json');
+const lockPath = path.join(baseDir, 'daemon.lock');
 const logPath = path.join(baseDir, 'daemon.log');
 const sessionsDir = path.join(baseDir, 'sessions');
 const sessionStore = new SessionStore(sessionsDir);
@@ -28,6 +33,15 @@ const version = readVersion();
 const token = crypto.randomBytes(24).toString('hex');
 const selectorValidationExemptCommands = new Set(['session_list', 'devices']);
 
+type DaemonLockInfo = {
+  pid: number;
+  version: string;
+  startedAt: number;
+  processStartTime?: string;
+};
+
+const daemonProcessStartTime = readProcessStartTime(process.pid) ?? undefined;
+
 function contextFromFlags(
   flags: CommandFlags | undefined,
   appBundleId?: string,
@@ -122,7 +136,7 @@ function writeInfo(port: number): void {
   fs.writeFileSync(logPath, '');
   fs.writeFileSync(
     infoPath,
-    JSON.stringify({ port, token, pid: process.pid, version }, null, 2),
+    JSON.stringify({ port, token, pid: process.pid, version, processStartTime: daemonProcessStartTime }, null, 2),
     {
       mode: 0o600,
     },
@@ -133,7 +147,73 @@ function removeInfo(): void {
   if (fs.existsSync(infoPath)) fs.unlinkSync(infoPath);
 }
 
+function readLockInfo(): DaemonLockInfo | null {
+  if (!fs.existsSync(lockPath)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(lockPath, 'utf8')) as DaemonLockInfo;
+    if (!Number.isInteger(parsed.pid) || parsed.pid <= 0) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function acquireDaemonLock(): boolean {
+  if (!fs.existsSync(baseDir)) fs.mkdirSync(baseDir, { recursive: true });
+  const lockData: DaemonLockInfo = {
+    pid: process.pid,
+    version,
+    startedAt: Date.now(),
+    processStartTime: daemonProcessStartTime,
+  };
+  const payload = JSON.stringify(lockData, null, 2);
+
+  const tryWriteLock = (): boolean => {
+    try {
+      fs.writeFileSync(lockPath, payload, { flag: 'wx', mode: 0o600 });
+      return true;
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'EEXIST') return false;
+      throw err;
+    }
+  };
+
+  if (tryWriteLock()) return true;
+  const existing = readLockInfo();
+  if (
+    existing?.pid
+    && existing.pid !== process.pid
+    && isAgentDeviceDaemonProcess(existing.pid, existing.processStartTime)
+  ) {
+    return false;
+  }
+  // Best-effort stale-lock cleanup: another process may win the race between unlink and re-create.
+  // We rely on the subsequent write with `wx` to enforce single-writer semantics.
+  try {
+    fs.unlinkSync(lockPath);
+  } catch {
+    // ignore
+  }
+  return tryWriteLock();
+}
+
+function releaseDaemonLock(): void {
+  const existing = readLockInfo();
+  if (existing && existing.pid !== process.pid) return;
+  try {
+    if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
+  } catch {
+    // ignore
+  }
+}
+
 function start(): void {
+  if (!acquireDaemonLock()) {
+    process.stderr.write('Daemon lock is held by another process; exiting.\n');
+    process.exit(0);
+    return;
+  }
+
   const server = net.createServer((socket) => {
     let buffer = '';
     socket.setEncoding('utf8');
@@ -172,18 +252,28 @@ function start(): void {
     }
   });
 
+  let shuttingDown = false;
+  const closeServer = async (): Promise<void> => {
+    await new Promise<void>((resolve) => {
+      try {
+        server.close(() => resolve());
+      } catch {
+        resolve();
+      }
+    });
+  };
   const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    await closeServer();
     const sessionsToStop = sessionStore.toArray();
     for (const session of sessionsToStop) {
-      if (session.device.platform === 'ios' && session.device.kind === 'simulator') {
-        await stopIosRunnerSession(session.device.id);
-      }
       sessionStore.writeSessionLog(session);
     }
-    server.close(() => {
-      removeInfo();
-      process.exit(0);
-    });
+    await stopAllIosRunnerSessions();
+    removeInfo();
+    releaseDaemonLock();
+    process.exit(0);
   };
 
   process.on('SIGINT', () => {

package/src/platforms/android/__tests__/index.test.ts

@@ -1,6 +1,9 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { openAndroidApp, parseAndroidLaunchComponent } from '../index.ts';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { openAndroidApp, parseAndroidLaunchComponent, swipeAndroid } from '../index.ts';
 import type { DeviceInfo } from '../../../utils/device.ts';
 import { AppError } from '../../../utils/errors.ts';
 import { findBounds, parseUiHierarchy } from '../ui-hierarchy.ts';
@@ -110,3 +113,45 @@ test('openAndroidApp rejects activity override for deep link URLs', async () =>
     },
   );
 });
+
+test('swipeAndroid invokes adb input swipe with duration', async () => {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-device-swipe-test-'));
+  const adbPath = path.join(tmpDir, 'adb');
+  const argsLogPath = path.join(tmpDir, 'args.log');
+  await fs.writeFile(
+    adbPath,
+    '#!/bin/sh\nprintf "%s\\n" "$@" > "$AGENT_DEVICE_TEST_ARGS_FILE"\nexit 0\n',
+    'utf8',
+  );
+  await fs.chmod(adbPath, 0o755);
+
+  const previousPath = process.env.PATH;
+  const previousArgsFile = process.env.AGENT_DEVICE_TEST_ARGS_FILE;
+  process.env.PATH = `${tmpDir}${path.delimiter}${previousPath ?? ''}`;
+  process.env.AGENT_DEVICE_TEST_ARGS_FILE = argsLogPath;
+
+  const device: DeviceInfo = {
+    platform: 'android',
+    id: 'emulator-5554',
+    name: 'Pixel',
+    kind: 'emulator',
+    booted: true,
+  };
+
+  try {
+    await swipeAndroid(device, 10, 20, 30, 40, 250);
+    const args = (await fs.readFile(argsLogPath, 'utf8'))
+      .trim()
+      .split('\n')
+      .filter(Boolean);
+    assert.deepEqual(args, ['-s', 'emulator-5554', 'shell', 'input', 'swipe', '10', '20', '30', '40', '250']);
+  } finally {
+    process.env.PATH = previousPath;
+    if (previousArgsFile === undefined) {
+      delete process.env.AGENT_DEVICE_TEST_ARGS_FILE;
+    } else {
+      process.env.AGENT_DEVICE_TEST_ARGS_FILE = previousArgsFile;
+    }
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+});

package/src/platforms/android/index.ts

@@ -333,6 +333,29 @@ export async function pressAndroid(device: DeviceInfo, x: number, y: number): Pr
   await runCmd('adb', adbArgs(device, ['shell', 'input', 'tap', String(x), String(y)]));
 }
 
+export async function swipeAndroid(
+  device: DeviceInfo,
+  x1: number,
+  y1: number,
+  x2: number,
+  y2: number,
+  durationMs = 250,
+): Promise<void> {
+  await runCmd(
+    'adb',
+    adbArgs(device, [
+      'shell',
+      'input',
+      'swipe',
+      String(x1),
+      String(y1),
+      String(x2),
+      String(y2),
+      String(durationMs),
+    ]),
+  );
+}
+
 export async function backAndroid(device: DeviceInfo): Promise<void> {
   await runCmd('adb', adbArgs(device, ['shell', 'input', 'keyevent', '4']));
 }

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

@@ -54,7 +54,7 @@ export async function openIosApp(
   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 in v1');
+      throw new AppError('UNSUPPORTED_OPERATION', 'Deep link open is only supported on iOS simulators');
     }
     await ensureBootedSimulator(device);
     await runCmd('open', ['-a', 'Simulator'], { allowFailure: true });
@@ -249,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`,
     );
   }
 }