agent-device 0.4.0 → 0.4.1

package/src/daemon/handlers/snapshot.ts

@@ -1,6 +1,6 @@
 import { dispatchCommand, resolveTargetDevice } from '../../core/dispatch.ts';
 import { isCommandSupportedOnDevice } from '../../core/capabilities.ts';
-import { runIosRunnerCommand } from '../../platforms/ios/runner-client.ts';
+import { runIosRunnerCommand, stopIosRunnerSession } from '../../platforms/ios/runner-client.ts';
 import { snapshotAndroid } from '../../platforms/android/index.ts';
 import {
   attachRefs,
@@ -78,45 +78,47 @@ export async function handleSnapshotCommands(params: {
       }
       snapshotScope = resolved;
     }
-    const data = (await dispatchCommand(device, 'snapshot', [], req.flags?.out, {
-      ...contextFromFlags(
-        logPath,
-        { ...req.flags, snapshotScope },
-        appBundleId,
-        session?.trace?.outPath,
-      ),
-    })) as {
-      nodes?: RawSnapshotNode[];
-      truncated?: boolean;
-      backend?: 'ax' | 'xctest' | 'android';
-    };
-    const rawNodes = data?.nodes ?? [];
-    const nodes = attachRefs(req.flags?.snapshotRaw ? rawNodes : pruneGroupNodes(rawNodes));
-    const snapshot: SnapshotState = {
-      nodes,
-      truncated: data?.truncated,
-      createdAt: Date.now(),
-      backend: data?.backend,
-    };
-    const nextSession: SessionState = session
-      ? { ...session, snapshot }
-      : { name: sessionName, device, createdAt: Date.now(), appBundleId, snapshot, actions: [] };
-    recordIfSession(sessionStore, nextSession, req, {
-      nodes: nodes.length,
-      truncated: data?.truncated ?? false,
-    });
-    sessionStore.set(sessionName, nextSession);
-    return {
-      ok: true,
-      data: {
+    return await withSessionlessRunnerCleanup(session, device, async () => {
+      const data = (await dispatchCommand(device, 'snapshot', [], req.flags?.out, {
+        ...contextFromFlags(
+          logPath,
+          { ...req.flags, snapshotScope },
+          appBundleId,
+          session?.trace?.outPath,
+        ),
+      })) as {
+        nodes?: RawSnapshotNode[];
+        truncated?: boolean;
+        backend?: 'ax' | 'xctest' | 'android';
+      };
+      const rawNodes = data?.nodes ?? [];
+      const nodes = attachRefs(req.flags?.snapshotRaw ? rawNodes : pruneGroupNodes(rawNodes));
+      const snapshot: SnapshotState = {
         nodes,
+        truncated: data?.truncated,
+        createdAt: Date.now(),
+        backend: data?.backend,
+      };
+      const nextSession: SessionState = session
+        ? { ...session, snapshot }
+        : { name: sessionName, device, createdAt: Date.now(), appBundleId, snapshot, actions: [] };
+      recordIfSession(sessionStore, nextSession, req, {
+        nodes: nodes.length,
         truncated: data?.truncated ?? false,
-        appName: nextSession.appBundleId
-          ? (nextSession.appName ?? nextSession.appBundleId)
-          : undefined,
-        appBundleId: nextSession.appBundleId,
-      },
-    };
+      });
+      sessionStore.set(sessionName, nextSession);
+      return {
+        ok: true,
+        data: {
+          nodes,
+          truncated: data?.truncated ?? false,
+          appName: nextSession.appBundleId
+            ? (nextSession.appName ?? nextSession.appBundleId)
+            : undefined,
+          appBundleId: nextSession.appBundleId,
+        },
+      };
+    });
   }
 
   if (command === 'wait') {
@@ -140,125 +142,127 @@ export async function handleSnapshotCommands(params: {
         error: { code: 'UNSUPPORTED_OPERATION', message: 'wait is not supported on this device' },
       };
     }
-    let text: string;
-    let timeoutMs: number | null;
-    if (parsed.kind === 'selector') {
-      const timeout = parsed.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-      const start = Date.now();
-      while (Date.now() - start < timeout) {
-        const data = (await dispatchCommand(device, 'snapshot', [], req.flags?.out, {
-          ...contextFromFlags(
-            logPath,
-            {
-              ...req.flags,
-              snapshotInteractiveOnly: false,
-              snapshotCompact: false,
-            },
-            session?.appBundleId,
-            session?.trace?.outPath,
-          ),
-        })) as {
-          nodes?: RawSnapshotNode[];
-          truncated?: boolean;
-          backend?: 'ax' | 'xctest' | 'android';
-        };
-        const rawNodes = data?.nodes ?? [];
-        const nodes = attachRefs(req.flags?.snapshotRaw ? rawNodes : pruneGroupNodes(rawNodes));
-        if (session) {
-          session.snapshot = {
-            nodes,
-            truncated: data?.truncated,
-            createdAt: Date.now(),
-            backend: data?.backend,
+    return await withSessionlessRunnerCleanup(session, device, async () => {
+      let text: string;
+      let timeoutMs: number | null;
+      if (parsed.kind === 'selector') {
+        const timeout = parsed.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+          const data = (await dispatchCommand(device, 'snapshot', [], req.flags?.out, {
+            ...contextFromFlags(
+              logPath,
+              {
+                ...req.flags,
+                snapshotInteractiveOnly: false,
+                snapshotCompact: false,
+              },
+              session?.appBundleId,
+              session?.trace?.outPath,
+            ),
+          })) as {
+            nodes?: RawSnapshotNode[];
+            truncated?: boolean;
+            backend?: 'ax' | 'xctest' | 'android';
           };
-          sessionStore.set(sessionName, session);
-        }
-        const match = findSelectorChainMatch(nodes, parsed.selector, { platform: device.platform });
-        if (match) {
-          recordIfSession(sessionStore, session, req, {
-            selector: match.selector.raw,
-            waitedMs: Date.now() - start,
-          });
-          return {
-            ok: true,
-            data: {
+          const rawNodes = data?.nodes ?? [];
+          const nodes = attachRefs(req.flags?.snapshotRaw ? rawNodes : pruneGroupNodes(rawNodes));
+          if (session) {
+            session.snapshot = {
+              nodes,
+              truncated: data?.truncated,
+              createdAt: Date.now(),
+              backend: data?.backend,
+            };
+            sessionStore.set(sessionName, session);
+          }
+          const match = findSelectorChainMatch(nodes, parsed.selector, { platform: device.platform });
+          if (match) {
+            recordIfSession(sessionStore, session, req, {
               selector: match.selector.raw,
               waitedMs: Date.now() - start,
-            },
-          };
+            });
+            return {
+              ok: true,
+              data: {
+                selector: match.selector.raw,
+                waitedMs: Date.now() - start,
+              },
+            };
+          }
+          await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
         }
-        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-      }
-      return {
-        ok: false,
-        error: {
-          code: 'COMMAND_FAILED',
-          message: `wait timed out for selector: ${parsed.selectorExpression}`,
-        },
-      };
-    } else if (parsed.kind === 'ref') {
-      if (!session?.snapshot) {
-        return {
-          ok: false,
-          error: {
-            code: 'INVALID_ARGS',
-            message: 'Ref wait requires an existing snapshot in session.',
-          },
-        };
-      }
-      const ref = normalizeRef(parsed.rawRef);
-      if (!ref) {
-        return {
-          ok: false,
-          error: { code: 'INVALID_ARGS', message: `Invalid ref: ${parsed.rawRef}` },
-        };
-      }
-      const node = findNodeByRef(session.snapshot.nodes, ref);
-      const resolved = node ? resolveRefLabel(node, session.snapshot.nodes) : undefined;
-      if (!resolved) {
         return {
           ok: false,
           error: {
             code: 'COMMAND_FAILED',
-            message: `Ref ${parsed.rawRef} not found or has no label`,
+            message: `wait timed out for selector: ${parsed.selectorExpression}`,
           },
         };
-      }
-      text = resolved;
-      timeoutMs = parsed.timeoutMs;
-    } else {
-      text = parsed.text;
-      timeoutMs = parsed.timeoutMs;
-    }
-    if (!text) {
-      return { ok: false, error: { code: 'INVALID_ARGS', message: 'wait requires text' } };
-    }
-    const timeout = timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      if (device.platform === 'ios') {
-        const result = (await runIosRunnerCommand(
-          device,
-          { command: 'findText', text, appBundleId: session?.appBundleId },
-          { verbose: req.flags?.verbose, logPath, traceLogPath: session?.trace?.outPath },
-        )) as { found?: boolean };
-        if (result?.found) {
-          recordIfSession(sessionStore, session, req, { text, waitedMs: Date.now() - start });
-          return { ok: true, data: { text, waitedMs: Date.now() - start } };
+      } else if (parsed.kind === 'ref') {
+        if (!session?.snapshot) {
+          return {
+            ok: false,
+            error: {
+              code: 'INVALID_ARGS',
+              message: 'Ref wait requires an existing snapshot in session.',
+            },
+          };
+        }
+        const ref = normalizeRef(parsed.rawRef);
+        if (!ref) {
+          return {
+            ok: false,
+            error: { code: 'INVALID_ARGS', message: `Invalid ref: ${parsed.rawRef}` },
+          };
+        }
+        const node = findNodeByRef(session.snapshot.nodes, ref);
+        const resolved = node ? resolveRefLabel(node, session.snapshot.nodes) : undefined;
+        if (!resolved) {
+          return {
+            ok: false,
+            error: {
+              code: 'COMMAND_FAILED',
+              message: `Ref ${parsed.rawRef} not found or has no label`,
+            },
+          };
         }
-      } else if (device.platform === 'android') {
-        const androidResult = await snapshotAndroid(device, { scope: text });
-        if (findNodeByLabel(attachRefs(androidResult.nodes ?? []), text)) {
-          recordIfSession(sessionStore, session, req, { text, waitedMs: Date.now() - start });
-          return { ok: true, data: { text, waitedMs: Date.now() - start } };
+        text = resolved;
+        timeoutMs = parsed.timeoutMs;
+      } else {
+        text = parsed.text;
+        timeoutMs = parsed.timeoutMs;
+      }
+      if (!text) {
+        return { ok: false, error: { code: 'INVALID_ARGS', message: 'wait requires text' } };
+      }
+      const timeout = timeoutMs ?? DEFAULT_TIMEOUT_MS;
+      const start = Date.now();
+      while (Date.now() - start < timeout) {
+        if (device.platform === 'ios') {
+          const result = (await runIosRunnerCommand(
+            device,
+            { command: 'findText', text, appBundleId: session?.appBundleId },
+            { verbose: req.flags?.verbose, logPath, traceLogPath: session?.trace?.outPath },
+          )) as { found?: boolean };
+          if (result?.found) {
+            recordIfSession(sessionStore, session, req, { text, waitedMs: Date.now() - start });
+            return { ok: true, data: { text, waitedMs: Date.now() - start } };
+          }
+        } else if (device.platform === 'android') {
+          const androidResult = await snapshotAndroid(device, { scope: text });
+          if (findNodeByLabel(attachRefs(androidResult.nodes ?? []), text)) {
+            recordIfSession(sessionStore, session, req, { text, waitedMs: Date.now() - start });
+            return { ok: true, data: { text, waitedMs: Date.now() - start } };
+          }
         }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
       }
-      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-    }
-    return {
-      ok: false,
-      error: { code: 'COMMAND_FAILED', message: `wait timed out for text: ${text}` },
-    };
+      return {
+        ok: false,
+        error: { code: 'COMMAND_FAILED', message: `wait timed out for text: ${text}` },
+      };
+    });
   }
 
   if (command === 'alert') {
@@ -273,37 +277,39 @@ export async function handleSnapshotCommands(params: {
         },
       };
     }
-    if (action === 'wait') {
-      const timeout = parseTimeout(req.positionals?.[1]) ?? DEFAULT_TIMEOUT_MS;
-      const start = Date.now();
-      while (Date.now() - start < timeout) {
-        try {
-          const data = await runIosRunnerCommand(
-            device,
-            { command: 'alert', action: 'get', appBundleId: session?.appBundleId },
-            { verbose: req.flags?.verbose, logPath, traceLogPath: session?.trace?.outPath },
-          );
-          recordIfSession(sessionStore, session, req, data as Record<string, unknown>);
-          return { ok: true, data };
-        } catch {
-          // keep waiting
+    return await withSessionlessRunnerCleanup(session, device, async () => {
+      if (action === 'wait') {
+        const timeout = parseTimeout(req.positionals?.[1]) ?? DEFAULT_TIMEOUT_MS;
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+          try {
+            const data = await runIosRunnerCommand(
+              device,
+              { command: 'alert', action: 'get', appBundleId: session?.appBundleId },
+              { verbose: req.flags?.verbose, logPath, traceLogPath: session?.trace?.outPath },
+            );
+            recordIfSession(sessionStore, session, req, data as Record<string, unknown>);
+            return { ok: true, data };
+          } catch {
+            // keep waiting
+          }
+          await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
         }
-        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        return { ok: false, error: { code: 'COMMAND_FAILED', message: 'alert wait timed out' } };
       }
-      return { ok: false, error: { code: 'COMMAND_FAILED', message: 'alert wait timed out' } };
-    }
-    const data = await runIosRunnerCommand(
-      device,
-      {
-        command: 'alert',
-        action:
-          action === 'accept' || action === 'dismiss' ? (action as 'accept' | 'dismiss') : 'get',
-        appBundleId: session?.appBundleId,
-      },
-      { verbose: req.flags?.verbose, logPath, traceLogPath: session?.trace?.outPath },
-    );
-    recordIfSession(sessionStore, session, req, data as Record<string, unknown>);
-    return { ok: true, data };
+      const data = await runIosRunnerCommand(
+        device,
+        {
+          command: 'alert',
+          action:
+            action === 'accept' || action === 'dismiss' ? (action as 'accept' | 'dismiss') : 'get',
+          appBundleId: session?.appBundleId,
+        },
+        { verbose: req.flags?.verbose, logPath, traceLogPath: session?.trace?.outPath },
+      );
+      recordIfSession(sessionStore, session, req, data as Record<string, unknown>);
+      return { ok: true, data };
+    });
   }
 
   if (command === 'settings') {
@@ -328,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;
@@ -398,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,

package/src/daemon/session-store.ts

@@ -49,6 +49,9 @@ export class SessionStore {
     if (entry.flags?.noRecord) return;
     if (entry.flags?.saveScript) {
       session.recordSession = true;
+      if (typeof entry.flags.saveScript === 'string') {
+        session.saveScriptPath = SessionStore.expandHome(entry.flags.saveScript);
+      }
     }
     session.actions.push({
       ts: Date.now(),
@@ -62,10 +65,9 @@ export class SessionStore {
   writeSessionLog(session: SessionState): void {
     try {
       if (!session.recordSession) return;
-      if (!fs.existsSync(this.sessionsDir)) fs.mkdirSync(this.sessionsDir, { recursive: true });
-      const safeName = session.name.replace(/[^a-zA-Z0-9._-]/g, '_');
-      const timestamp = new Date(session.createdAt).toISOString().replace(/[:.]/g, '-');
-      const scriptPath = path.join(this.sessionsDir, `${safeName}-${timestamp}.ad`);
+      const scriptPath = this.resolveScriptPath(session);
+      const scriptDir = path.dirname(scriptPath);
+      if (!fs.existsSync(scriptDir)) fs.mkdirSync(scriptDir, { recursive: true });
       const script = formatScript(session, this.buildOptimizedActions(session));
       fs.writeFileSync(scriptPath, script);
     } catch {
@@ -86,6 +88,16 @@ export class SessionStore {
     return path.resolve(filePath);
   }
 
+  private resolveScriptPath(session: SessionState): string {
+    if (session.saveScriptPath) {
+      return SessionStore.expandHome(session.saveScriptPath);
+    }
+    if (!fs.existsSync(this.sessionsDir)) fs.mkdirSync(this.sessionsDir, { recursive: true });
+    const safeName = session.name.replace(/[^a-zA-Z0-9._-]/g, '_');
+    const timestamp = new Date(session.createdAt).toISOString().replace(/[:.]/g, '-');
+    return path.join(this.sessionsDir, `${safeName}-${timestamp}.ad`);
+  }
+
   private buildOptimizedActions(session: SessionState): SessionAction[] {
     const optimized: SessionAction[] = [];
     for (const action of session.actions) {

package/src/daemon/types.ts

@@ -27,6 +27,7 @@ export type SessionState = {
     startedAt: number;
   };
   recordSession?: boolean;
+  saveScriptPath?: string;
   actions: SessionAction[];
   recording?: {
     platform: 'ios' | 'android';
@@ -48,7 +49,7 @@ export type SessionAction = {
     snapshotScope?: string;
     snapshotRaw?: boolean;
     snapshotBackend?: 'ax' | 'xctest';
-    saveScript?: boolean;
+    saveScript?: boolean | string;
     noRecord?: boolean;
   };
   result?: Record<string, unknown>;

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();
@@ -38,6 +47,7 @@ async function ensureDaemon(): Promise<DaemonInfo> {
   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();
   }
 
@@ -56,12 +66,23 @@ 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;
   }
@@ -142,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));
 }