agent-device 0.4.1 → 0.4.2

package/src/daemon/handlers/session.ts

@@ -1,14 +1,13 @@
 import fs from 'node:fs';
 import { dispatchCommand, resolveTargetDevice } from '../../core/dispatch.ts';
 import { isCommandSupportedOnDevice } from '../../core/capabilities.ts';
-import { isDeepLinkTarget } from '../../core/open-target.ts';
+import { isDeepLinkTarget, resolveIosDeviceDeepLinkBundleId } from '../../core/open-target.ts';
 import { AppError, asAppError } from '../../utils/errors.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
 import type { DaemonRequest, DaemonResponse, SessionAction, SessionState } from '../types.ts';
 import { SessionStore } from '../session-store.ts';
 import { contextFromFlags } from '../context.ts';
 import { ensureDeviceReady } from '../device-ready.ts';
-import { resolveIosAppStateFromSnapshots } from '../app-state.ts';
 import { stopIosRunnerSession } from '../../platforms/ios/runner-client.ts';
 import { attachRefs, type RawSnapshotNode, type SnapshotState } from '../../utils/snapshot.ts';
 import { extractNodeText, normalizeType, pruneGroupNodes } from '../snapshot-processing.ts';
@@ -26,17 +25,61 @@ type ReinstallOps = {
   android: (device: DeviceInfo, app: string, appPath: string) => Promise<{ package: string }>;
 };
 
+const IOS_APPSTATE_SESSION_REQUIRED_MESSAGE =
+  'iOS appstate requires an active session on the target device. Run open first (for example: open --session sim --platform ios --device "<name>" <app>).';
+
+function requireSessionOrExplicitSelector(
+  command: string,
+  session: SessionState | undefined,
+  flags: DaemonRequest['flags'] | undefined,
+): DaemonResponse | null {
+  if (session || hasExplicitDeviceSelector(flags)) {
+    return null;
+  }
+  return {
+    ok: false,
+    error: {
+      code: 'INVALID_ARGS',
+      message: `${command} requires an active session or an explicit device selector (e.g. --platform ios).`,
+    },
+  };
+}
+
 function hasExplicitDeviceSelector(flags: DaemonRequest['flags'] | undefined): boolean {
   return Boolean(flags?.platform || flags?.device || flags?.udid || flags?.serial);
 }
 
+function hasExplicitSessionFlag(flags: DaemonRequest['flags'] | undefined): boolean {
+  return typeof flags?.session === 'string' && flags.session.trim().length > 0;
+}
+
+function selectorTargetsSessionDevice(
+  flags: DaemonRequest['flags'] | undefined,
+  session: SessionState | undefined,
+): boolean {
+  if (!session) return false;
+  if (!hasExplicitDeviceSelector(flags)) return true;
+  if (flags?.platform && flags.platform !== session.device.platform) return false;
+  if (flags?.udid && flags.udid !== session.device.id) return false;
+  if (flags?.serial && flags.serial !== session.device.id) return false;
+  if (flags?.device) {
+    return flags.device.trim().toLowerCase() === session.device.name.trim().toLowerCase();
+  }
+  return true;
+}
+
 async function resolveCommandDevice(params: {
   session: SessionState | undefined;
   flags: DaemonRequest['flags'] | undefined;
   ensureReadyFn: typeof ensureDeviceReady;
+  resolveTargetDeviceFn: typeof resolveTargetDevice;
   ensureReady?: boolean;
 }): Promise<DeviceInfo> {
-  const device = params.session?.device ?? (await resolveTargetDevice(params.flags ?? {}));
+  const shouldUseExplicitSelector = hasExplicitDeviceSelector(params.flags);
+  const device =
+    shouldUseExplicitSelector || !params.session
+      ? await params.resolveTargetDeviceFn(params.flags ?? {})
+      : params.session.device;
   if (params.ensureReady !== false) {
     await params.ensureReadyFn(device);
   }
@@ -54,10 +97,22 @@ const defaultReinstallOps: ReinstallOps = {
   },
 };
 
-async function resolveIosBundleIdForOpen(device: DeviceInfo, openTarget: string | undefined): Promise<string | undefined> {
-  if (device.platform !== 'ios' || !openTarget || isDeepLinkTarget(openTarget)) {
+async function resolveIosBundleIdForOpen(
+  device: DeviceInfo,
+  openTarget: string | undefined,
+  currentAppBundleId?: string,
+): Promise<string | undefined> {
+  if (device.platform !== 'ios' || !openTarget) return undefined;
+  if (isDeepLinkTarget(openTarget)) {
+    if (device.kind === 'device') {
+      return resolveIosDeviceDeepLinkBundleId(currentAppBundleId, openTarget);
+    }
     return undefined;
   }
+  return await tryResolveIosAppBundleId(device, openTarget);
+}
+
+async function tryResolveIosAppBundleId(device: DeviceInfo, openTarget: string): Promise<string | undefined> {
   try {
     const { resolveIosApp } = await import('../../platforms/ios/index.ts');
     return await resolveIosApp(device, openTarget);
@@ -66,6 +121,92 @@ async function resolveIosBundleIdForOpen(device: DeviceInfo, openTarget: string
   }
 }
 
+async function handleAppStateCommand(params: {
+  req: DaemonRequest;
+  sessionName: string;
+  sessionStore: SessionStore;
+  ensureReady: typeof ensureDeviceReady;
+  resolveDevice: typeof resolveTargetDevice;
+}): Promise<DaemonResponse> {
+  const { req, sessionName, sessionStore, ensureReady, resolveDevice } = params;
+  const session = sessionStore.get(sessionName);
+  const flags = req.flags ?? {};
+  if (!session && hasExplicitSessionFlag(flags)) {
+    const iOSSessionHint =
+      flags.platform === 'ios'
+        ? `No active session "${sessionName}". Run open with --session ${sessionName} first.`
+        : `No active session "${sessionName}". Run open with --session ${sessionName} first, or omit --session to query by device selector.`;
+    return {
+      ok: false,
+      error: {
+        code: 'SESSION_NOT_FOUND',
+        message: iOSSessionHint,
+      },
+    };
+  }
+  const guard = requireSessionOrExplicitSelector('appstate', session, flags);
+  if (guard) return guard;
+
+  const shouldUseSessionStateForIos = session?.device.platform === 'ios' && selectorTargetsSessionDevice(flags, session);
+  const targetsIos = flags.platform === 'ios';
+  if (targetsIos && !shouldUseSessionStateForIos) {
+    return {
+      ok: false,
+      error: {
+        code: 'SESSION_NOT_FOUND',
+        message: IOS_APPSTATE_SESSION_REQUIRED_MESSAGE,
+      },
+    };
+  }
+  if (shouldUseSessionStateForIos) {
+    const appName = session.appName ?? session.appBundleId;
+    if (!session.appName && !session.appBundleId) {
+      return {
+        ok: false,
+        error: {
+          code: 'COMMAND_FAILED',
+          message: 'No foreground app is tracked for this iOS session. Open an app in the session, then retry appstate.',
+        },
+      };
+    }
+    return {
+      ok: true,
+      data: {
+        platform: 'ios',
+        appName: appName ?? 'unknown',
+        appBundleId: session.appBundleId,
+        source: 'session',
+      },
+    };
+  }
+  const device = await resolveCommandDevice({
+    session,
+    flags,
+    ensureReadyFn: ensureReady,
+    resolveTargetDeviceFn: resolveDevice,
+    ensureReady: true,
+  });
+  if (device.platform === 'ios') {
+    return {
+      ok: false,
+      error: {
+        code: 'SESSION_NOT_FOUND',
+        message: IOS_APPSTATE_SESSION_REQUIRED_MESSAGE,
+      },
+    };
+  }
+  const { getAndroidAppState } = await import('../../platforms/android/index.ts');
+  const state = await getAndroidAppState(device);
+  return {
+    ok: true,
+    data: {
+      platform: 'android',
+      package: state.package,
+      activity: state.activity,
+    },
+  };
+}
+
 export async function handleSessionCommands(params: {
   req: DaemonRequest;
   sessionName: string;
@@ -74,6 +215,7 @@ export async function handleSessionCommands(params: {
   invoke: (req: DaemonRequest) => Promise<DaemonResponse>;
   dispatch?: typeof dispatchCommand;
   ensureReady?: typeof ensureDeviceReady;
+  resolveTargetDevice?: typeof resolveTargetDevice;
   reinstallOps?: ReinstallOps;
 }): Promise<DaemonResponse | null> {
   const {
@@ -84,10 +226,12 @@ export async function handleSessionCommands(params: {
     invoke,
     dispatch: dispatchOverride,
     ensureReady: ensureReadyOverride,
+    resolveTargetDevice: resolveTargetDeviceOverride,
     reinstallOps = defaultReinstallOps,
   } = params;
   const dispatch = dispatchOverride ?? dispatchCommand;
   const ensureReady = ensureReadyOverride ?? ensureDeviceReady;
+  const resolveDevice = resolveTargetDeviceOverride ?? resolveTargetDevice;
   const command = req.command;
 
   if (command === 'session_list') {
@@ -136,56 +280,50 @@ export async function handleSessionCommands(params: {
   if (command === 'apps') {
     const session = sessionStore.get(sessionName);
     const flags = req.flags ?? {};
-    if (!session && !hasExplicitDeviceSelector(flags)) {
-      return {
-        ok: false,
-        error: {
-          code: 'INVALID_ARGS',
-          message: 'apps requires an active session or an explicit device selector (e.g. --platform ios).',
-        },
-      };
-    }
-    const device = await resolveCommandDevice({ session, flags, ensureReadyFn: ensureReady, ensureReady: true });
+    const guard = requireSessionOrExplicitSelector(command, session, flags);
+    if (guard) return guard;
+    const device = await resolveCommandDevice({
+      session,
+      flags,
+      ensureReadyFn: ensureReady,
+      resolveTargetDeviceFn: resolveDevice,
+      ensureReady: true,
+    });
     if (!isCommandSupportedOnDevice('apps', device)) {
       return { ok: false, error: { code: 'UNSUPPORTED_OPERATION', message: 'apps is not supported on this device' } };
     }
+    const appsFilter = req.flags?.appsFilter ?? 'all';
     if (device.platform === 'ios') {
-      const { listSimulatorApps } = await import('../../platforms/ios/index.ts');
-      const apps = await listSimulatorApps(device);
-      if (req.flags?.appsMetadata) {
-        return { ok: true, data: { apps } };
-      }
+      const { listIosApps } = await import('../../platforms/ios/index.ts');
+      const apps = await listIosApps(device, appsFilter);
       const formatted = apps.map((app) =>
         app.name && app.name !== app.bundleId ? `${app.name} (${app.bundleId})` : app.bundleId,
       );
       return { ok: true, data: { apps: formatted } };
     }
-    const { listAndroidApps, listAndroidAppsMetadata } = await import('../../platforms/android/index.ts');
-    if (req.flags?.appsMetadata) {
-      const apps = await listAndroidAppsMetadata(device, req.flags?.appsFilter);
-      return { ok: true, data: { apps } };
-    }
-    const apps = await listAndroidApps(device, req.flags?.appsFilter);
-    return { ok: true, data: { apps } };
+    const { listAndroidApps } = await import('../../platforms/android/index.ts');
+    const apps = await listAndroidApps(device, appsFilter);
+    const formatted = apps.map((app) =>
+      app.name && app.name !== app.package ? `${app.name} (${app.package})` : app.package,
+    );
+    return { ok: true, data: { apps: formatted } };
   }
 
   if (command === 'boot') {
     const session = sessionStore.get(sessionName);
     const flags = req.flags ?? {};
-    if (!session && !hasExplicitDeviceSelector(flags)) {
-      return {
-        ok: false,
-        error: {
-          code: 'INVALID_ARGS',
-          message: 'boot requires an active session or an explicit device selector (e.g. --platform ios).',
-        },
-      };
-    }
-    const device = session?.device ?? (await resolveTargetDevice(flags));
+    const guard = requireSessionOrExplicitSelector(command, session, flags);
+    if (guard) return guard;
+    const device = await resolveCommandDevice({
+      session,
+      flags,
+      ensureReadyFn: ensureReady,
+      resolveTargetDeviceFn: resolveDevice,
+      ensureReady: true,
+    });
     if (!isCommandSupportedOnDevice('boot', device)) {
       return { ok: false, error: { code: 'UNSUPPORTED_OPERATION', message: 'boot is not supported on this device' } };
     }
-    await ensureReady(device);
     return {
       ok: true,
       data: {
@@ -199,61 +337,20 @@ export async function handleSessionCommands(params: {
   }
 
   if (command === 'appstate') {
-    const session = sessionStore.get(sessionName);
-    const flags = req.flags ?? {};
-    const device = await resolveCommandDevice({ session, flags, ensureReadyFn: ensureReady, ensureReady: true });
-    if (device.platform === 'ios') {
-      if (session?.appBundleId) {
-        return {
-          ok: true,
-          data: {
-            platform: 'ios',
-            appBundleId: session.appBundleId,
-            appName: session.appName ?? session.appBundleId,
-            source: 'session',
-          },
-        };
-      }
-      const snapshotResult = await resolveIosAppStateFromSnapshots(
-        device,
-        logPath,
-        session?.trace?.outPath,
-        req.flags,
-      );
-      return {
-        ok: true,
-        data: {
-          platform: 'ios',
-          appName: snapshotResult.appName,
-          appBundleId: snapshotResult.appBundleId,
-          source: snapshotResult.source,
-        },
-      };
-    }
-    const { getAndroidAppState } = await import('../../platforms/android/index.ts');
-    const state = await getAndroidAppState(device);
-    return {
-      ok: true,
-      data: {
-        platform: 'android',
-        package: state.package,
-        activity: state.activity,
-      },
-    };
+    return await handleAppStateCommand({
+      req,
+      sessionName,
+      sessionStore,
+      ensureReady,
+      resolveDevice,
+    });
   }
 
   if (command === 'reinstall') {
     const session = sessionStore.get(sessionName);
     const flags = req.flags ?? {};
-    if (!session && !hasExplicitDeviceSelector(flags)) {
-      return {
-        ok: false,
-        error: {
-          code: 'INVALID_ARGS',
-          message: 'reinstall requires an active session or an explicit device selector (e.g. --platform ios).',
-        },
-      };
-    }
+    const guard = requireSessionOrExplicitSelector(command, session, flags);
+    if (guard) return guard;
     const app = req.positionals?.[0]?.trim();
     const appPathInput = req.positionals?.[1]?.trim();
     if (!app || !appPathInput) {
@@ -269,7 +366,13 @@ export async function handleSessionCommands(params: {
         error: { code: 'INVALID_ARGS', message: `App binary not found: ${appPath}` },
       };
     }
-    const device = await resolveCommandDevice({ session, flags, ensureReadyFn: ensureReady, ensureReady: false });
+    const device = await resolveCommandDevice({
+      session,
+      flags,
+      ensureReadyFn: ensureReady,
+      resolveTargetDeviceFn: resolveDevice,
+      ensureReady: false,
+    });
     if (!isCommandSupportedOnDevice('reinstall', device)) {
       return {
         ok: false,
@@ -331,7 +434,8 @@ export async function handleSessionCommands(params: {
           },
         };
       }
-      const appBundleId = await resolveIosBundleIdForOpen(session.device, openTarget);
+      await ensureReady(session.device);
+      const appBundleId = await resolveIosBundleIdForOpen(session.device, openTarget, session.appBundleId);
       const openPositionals = requestedOpenTarget ? (req.positionals ?? []) : [openTarget];
       if (shouldRelaunch) {
         const closeTarget = appBundleId ?? openTarget;
@@ -377,7 +481,7 @@ export async function handleSessionCommands(params: {
         },
       };
     }
-    const device = await resolveTargetDevice(req.flags ?? {});
+    const device = await resolveDevice(req.flags ?? {});
     const inUse = sessionStore.toArray().find((s) => s.device.id === device.id);
     if (inUse) {
       return {
@@ -389,6 +493,7 @@ export async function handleSessionCommands(params: {
         },
       };
     }
+    await ensureReady(device);
     const appBundleId = await resolveIosBundleIdForOpen(device, openTarget);
     if (shouldRelaunch && openTarget) {
       const closeTarget = appBundleId ?? openTarget;

package/src/daemon/session-store.ts

@@ -177,7 +177,6 @@ function sanitizeFlags(flags: CommandFlags | undefined): SessionAction['flags']
     snapshotScope,
     snapshotRaw,
     snapshotBackend,
-    appsMetadata,
     relaunch,
     saveScript,
     noRecord,
@@ -195,7 +194,6 @@ function sanitizeFlags(flags: CommandFlags | undefined): SessionAction['flags']
     snapshotScope,
     snapshotRaw,
     snapshotBackend,
-    appsMetadata,
     relaunch,
     saveScript,
     noRecord,

package/src/daemon-client.ts

@@ -6,7 +6,10 @@ 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';
+import {
+  isAgentDeviceDaemonProcess,
+  stopProcessForTakeover,
+} from './utils/process-identity.ts';
 
 export type DaemonRequest = {
   token: string;
@@ -28,8 +31,20 @@ type DaemonInfo = {
   processStartTime?: string;
 };
 
+type DaemonLockInfo = {
+  pid: number;
+  processStartTime?: string;
+  startedAt?: number;
+};
+
+type DaemonMetadataState = {
+  hasInfo: boolean;
+  hasLock: boolean;
+};
+
 const baseDir = path.join(os.homedir(), '.agent-device');
 const infoPath = path.join(baseDir, 'daemon.json');
+const lockPath = path.join(baseDir, 'daemon.lock');
 const REQUEST_TIMEOUT_MS = resolveDaemonRequestTimeoutMs();
 const DAEMON_STARTUP_TIMEOUT_MS = 5000;
 const DAEMON_TAKEOVER_TERM_TIMEOUT_MS = 3000;
@@ -51,19 +66,54 @@ async function ensureDaemon(): Promise<DaemonInfo> {
     removeDaemonInfo();
   }
 
+  cleanupStaleDaemonLockIfSafe();
   await startDaemon();
+  const started = await waitForDaemonInfo(DAEMON_STARTUP_TIMEOUT_MS);
+  if (started) return started;
 
+  if (await recoverDaemonLockHolder()) {
+    await startDaemon();
+    const recovered = await waitForDaemonInfo(DAEMON_STARTUP_TIMEOUT_MS);
+    if (recovered) return recovered;
+  }
+
+  throw new AppError('COMMAND_FAILED', 'Failed to start daemon', {
+    kind: 'daemon_startup_failed',
+    infoPath,
+    lockPath,
+    hint: resolveDaemonStartupHint(getDaemonMetadataState()),
+  });
+}
+
+async function waitForDaemonInfo(timeoutMs: number): Promise<DaemonInfo | null> {
   const start = Date.now();
-  while (Date.now() - start < DAEMON_STARTUP_TIMEOUT_MS) {
+  while (Date.now() - start < timeoutMs) {
     const info = readDaemonInfo();
     if (info && (await canConnect(info))) return info;
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
+  return null;
+}
 
-  throw new AppError('COMMAND_FAILED', 'Failed to start daemon', {
-    infoPath,
-    hint: 'Run pnpm build, or delete ~/.agent-device/daemon.json if stale.',
+async function recoverDaemonLockHolder(): Promise<boolean> {
+  const state = getDaemonMetadataState();
+  if (!state.hasLock || state.hasInfo) return false;
+  const lockInfo = readDaemonLockInfo();
+  if (!lockInfo) {
+    removeDaemonLock();
+    return true;
+  }
+  if (!isAgentDeviceDaemonProcess(lockInfo.pid, lockInfo.processStartTime)) {
+    removeDaemonLock();
+    return true;
+  }
+  await stopProcessForTakeover(lockInfo.pid, {
+    termTimeoutMs: DAEMON_TAKEOVER_TERM_TIMEOUT_MS,
+    killTimeoutMs: DAEMON_TAKEOVER_KILL_TIMEOUT_MS,
+    expectedStartTime: lockInfo.processStartTime,
   });
+  removeDaemonLock();
+  return true;
 }
 
 async function stopDaemonProcessForTakeover(info: DaemonInfo): Promise<void> {
@@ -75,24 +125,65 @@ async function stopDaemonProcessForTakeover(info: DaemonInfo): Promise<void> {
 }
 
 function readDaemonInfo(): DaemonInfo | null {
-  if (!fs.existsSync(infoPath)) return null;
+  const data = readJsonFile(infoPath) as DaemonInfo | null;
+  if (!data || !data.port || !data.token) return null;
+  return {
+    ...data,
+    pid: Number.isInteger(data.pid) && data.pid > 0 ? data.pid : 0,
+  };
+}
+
+function readDaemonLockInfo(): DaemonLockInfo | null {
+  const data = readJsonFile(lockPath) as DaemonLockInfo | null;
+  if (!data || !Number.isInteger(data.pid) || data.pid <= 0) {
+    return null;
+  }
+  return data;
+}
+
+function removeDaemonInfo(): void {
+  removeFileIfExists(infoPath);
+}
+
+function removeDaemonLock(): void {
+  removeFileIfExists(lockPath);
+}
+
+function cleanupStaleDaemonLockIfSafe(): void {
+  const state = getDaemonMetadataState();
+  if (!state.hasLock || state.hasInfo) return;
+  const lockInfo = readDaemonLockInfo();
+  if (!lockInfo) {
+    removeDaemonLock();
+    return;
+  }
+  if (isAgentDeviceDaemonProcess(lockInfo.pid, lockInfo.processStartTime)) {
+    return;
+  }
+  removeDaemonLock();
+}
+
+function getDaemonMetadataState(): DaemonMetadataState {
+  return {
+    hasInfo: fs.existsSync(infoPath),
+    hasLock: fs.existsSync(lockPath),
+  };
+}
+
+function readJsonFile(filePath: string): unknown | null {
+  if (!fs.existsSync(filePath)) return null;
   try {
-    const data = JSON.parse(fs.readFileSync(infoPath, 'utf8')) as DaemonInfo;
-    if (!data.port || !data.token) return null;
-    return {
-      ...data,
-      pid: Number.isInteger(data.pid) && data.pid > 0 ? data.pid : 0,
-    };
+    return JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown;
   } catch {
     return null;
   }
 }
 
-function removeDaemonInfo(): void {
+function removeFileIfExists(filePath: string): void {
   try {
-    if (fs.existsSync(infoPath)) fs.unlinkSync(infoPath);
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
   } catch {
-    // Best-effort cleanup only; daemon can still overwrite this file on startup.
+    // Best-effort cleanup only.
   }
 }
 
@@ -164,9 +255,18 @@ 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;
+  if (!raw) return 90000;
   const parsed = Number(raw);
-  if (!Number.isFinite(parsed)) return 180000;
+  if (!Number.isFinite(parsed)) return 90000;
   return Math.max(1000, Math.floor(parsed));
 }
+
+export function resolveDaemonStartupHint(state: { hasInfo: boolean; hasLock: boolean }): string {
+  if (state.hasLock && !state.hasInfo) {
+    return 'Detected ~/.agent-device/daemon.lock without daemon.json. If no agent-device daemon process is running, delete ~/.agent-device/daemon.lock and retry.';
+  }
+  if (state.hasLock && state.hasInfo) {
+    return 'Daemon metadata may be stale. If no agent-device daemon process is running, delete ~/.agent-device/daemon.json and ~/.agent-device/daemon.lock, then retry.';
+  }
+  return 'Daemon metadata is missing or stale. Delete ~/.agent-device/daemon.json if present and retry.';
+}