fix: address lifecycle review findings

Author: thymikee

src/daemon-client.ts

@@ -164,6 +164,7 @@ async function sendRequest(info: DaemonInfo, req: DaemonRequest): Promise<Daemon
 }
 
 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 180000;

src/daemon.ts

@@ -187,6 +187,8 @@ function acquireDaemonLock(): boolean {
   ) {
     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 {
@@ -251,19 +253,27 @@ 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) {
       sessionStore.writeSessionLog(session);
     }
     await stopAllIosRunnerSessions();
-    server.close(() => {
-      removeInfo();
-      releaseDaemonLock();
-      process.exit(0);
-    });
+    removeInfo();
+    releaseDaemonLock();
+    process.exit(0);
   };
 
   process.on('SIGINT', () => {

src/daemon/handlers/snapshot.ts

@@ -1,7 +1,6 @@
 import { dispatchCommand, resolveTargetDevice } from '../../core/dispatch.ts';
 import { isCommandSupportedOnDevice } from '../../core/capabilities.ts';
-import { runIosRunnerCommand } from '../../platforms/ios/runner-client.ts';
-import { stopIosRunnerSession } from '../../platforms/ios/runner-client.ts';
+import { runIosRunnerCommand, stopIosRunnerSession } from '../../platforms/ios/runner-client.ts';
 import { snapshotAndroid } from '../../platforms/android/index.ts';
 import {
   attachRefs,
@@ -79,8 +78,7 @@ export async function handleSnapshotCommands(params: {
       }
       snapshotScope = resolved;
     }
-    const shouldCleanupSessionlessIosRunner = !session && device.platform === 'ios';
-    try {
+    return await withSessionlessRunnerCleanup(session, device, async () => {
       const data = (await dispatchCommand(device, 'snapshot', [], req.flags?.out, {
         ...contextFromFlags(
           logPath,
@@ -120,11 +118,7 @@ export async function handleSnapshotCommands(params: {
           appBundleId: nextSession.appBundleId,
         },
       };
-    } finally {
-      if (shouldCleanupSessionlessIosRunner) {
-        await stopIosRunnerSession(device.id);
-      }
-    }
+    });
   }
 
   if (command === 'wait') {
@@ -148,8 +142,7 @@ export async function handleSnapshotCommands(params: {
         error: { code: 'UNSUPPORTED_OPERATION', message: 'wait is not supported on this device' },
       };
     }
-    const shouldCleanupSessionlessIosRunner = !session && device.platform === 'ios';
-    try {
+    return await withSessionlessRunnerCleanup(session, device, async () => {
       let text: string;
       let timeoutMs: number | null;
       if (parsed.kind === 'selector') {
@@ -269,11 +262,7 @@ export async function handleSnapshotCommands(params: {
         ok: false,
         error: { code: 'COMMAND_FAILED', message: `wait timed out for text: ${text}` },
       };
-    } finally {
-      if (shouldCleanupSessionlessIosRunner) {
-        await stopIosRunnerSession(device.id);
-      }
-    }
+    });
   }
 
   if (command === 'alert') {
@@ -288,8 +277,7 @@ export async function handleSnapshotCommands(params: {
         },
       };
     }
-    const shouldCleanupSessionlessIosRunner = !session && device.platform === 'ios';
-    try {
+    return await withSessionlessRunnerCleanup(session, device, async () => {
       if (action === 'wait') {
         const timeout = parseTimeout(req.positionals?.[1]) ?? DEFAULT_TIMEOUT_MS;
         const start = Date.now();
@@ -321,11 +309,7 @@ export async function handleSnapshotCommands(params: {
       );
       recordIfSession(sessionStore, session, req, data as Record<string, unknown>);
       return { ok: true, data };
-    } finally {
-      if (shouldCleanupSessionlessIosRunner) {
-        await stopIosRunnerSession(device.id);
-      }
-    }
+    });
   }
 
   if (command === 'settings') {
@@ -350,18 +334,20 @@ export async function handleSnapshotCommands(params: {
         },
       };
     }
-    const appBundleId = session?.appBundleId;
-    const data = await dispatchCommand(
-      device,
-      'settings',
-      [setting, state, appBundleId ?? ''],
-      req.flags?.out,
-      {
-        ...contextFromFlags(logPath, req.flags, appBundleId, session?.trace?.outPath),
-      },
-    );
-    recordIfSession(sessionStore, session, req, data ?? { setting, state });
-    return { ok: true, data: data ?? { setting, state } };
+    return await withSessionlessRunnerCleanup(session, device, async () => {
+      const appBundleId = session?.appBundleId;
+      const data = await dispatchCommand(
+        device,
+        'settings',
+        [setting, state, appBundleId ?? ''],
+        req.flags?.out,
+        {
+          ...contextFromFlags(logPath, req.flags, appBundleId, session?.trace?.outPath),
+        },
+      );
+      recordIfSession(sessionStore, session, req, data ?? { setting, state });
+      return { ok: true, data: data ?? { setting, state } };
+    });
   }
 
   return null;
@@ -420,6 +406,23 @@ async function resolveSessionDevice(
   return { session, device };
 }
 
+async function withSessionlessRunnerCleanup<T>(
+  session: SessionState | undefined,
+  device: SessionState['device'],
+  task: () => Promise<T>,
+): Promise<T> {
+  const shouldCleanupSessionlessIosRunner = !session && device.platform === 'ios';
+  try {
+    return await task();
+  } finally {
+    // Sessionless iOS commands intentionally stop the runner to avoid leaked xcodebuild processes.
+    // For multi-command flows, keep an active session via `open` so the runner can be reused.
+    if (shouldCleanupSessionlessIosRunner) {
+      await stopIosRunnerSession(device.id);
+    }
+  }
+}
+
 function recordIfSession(
   sessionStore: SessionStore,
   session: SessionState | undefined,

src/platforms/ios/runner-client.ts

@@ -140,8 +140,9 @@ async function executeRunnerCommand(
   command: RunnerCommand,
   options: { verbose?: boolean; logPath?: string; traceLogPath?: string } = {},
 ): Promise<Record<string, unknown>> {
+  let session: RunnerSession | undefined;
   try {
-    const session = await ensureRunnerSession(device, options);
+    session = await ensureRunnerSession(device, options);
     const timeoutMs = session.ready ? RUNNER_COMMAND_TIMEOUT_MS : RUNNER_STARTUP_TIMEOUT_MS;
     return await executeRunnerCommandWithSession(
       device,
@@ -157,8 +158,12 @@ async function executeRunnerCommand(
       typeof appErr.message === 'string' &&
       appErr.message.includes('Runner did not accept connection')
     ) {
-      await stopIosRunnerSession(device.id);
-      const session = await ensureRunnerSession(device, options);
+      if (session) {
+        await stopRunnerSession(session);
+      } else {
+        await stopIosRunnerSession(device.id);
+      }
+      session = await ensureRunnerSession(device, options);
       const response = await waitForRunner(
         session.device,
         session.port,
@@ -217,12 +222,17 @@ export async function stopIosRunnerSession(deviceId: string): Promise<void> {
 }
 
 export async function stopAllIosRunnerSessions(): Promise<void> {
-  while (runnerSessions.size > 0) {
-    const pending = Array.from(runnerSessions.keys());
-    await Promise.allSettled(pending.map(async (deviceId) => {
-      await stopIosRunnerSession(deviceId);
-    }));
-  }
+  // Shutdown cleanup drains the sessions known at invocation time; daemon shutdown closes intake.
+  const pending = Array.from(runnerSessions.keys());
+  await Promise.allSettled(pending.map(async (deviceId) => {
+    await stopIosRunnerSession(deviceId);
+  }));
+}
+
+async function stopRunnerSession(session: RunnerSession): Promise<void> {
+  await withRunnerSessionLock(session.deviceId, async () => {
+    await stopRunnerSessionInternal(session.deviceId, session);
+  });
 }
 
 async function stopRunnerSessionInternal(deviceId: string, sessionOverride?: RunnerSession): Promise<void> {