agent-device 0.4.2 → 0.5.0

package/src/daemon-client.ts

@@ -1,272 +0,0 @@
-import net from 'node:net';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-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 {
-  isAgentDeviceDaemonProcess,
-  stopProcessForTakeover,
-} from './utils/process-identity.ts';
-
-export type DaemonRequest = {
-  token: string;
-  session: string;
-  command: string;
-  positionals: string[];
-  flags?: CommandFlags;
-};
-
-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;
-  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;
-const DAEMON_TAKEOVER_KILL_TIMEOUT_MS = 1000;
-
-export async function sendToDaemon(req: Omit<DaemonRequest, 'token'>): Promise<DaemonResponse> {
-  const info = await ensureDaemon();
-  const request = { ...req, token: info.token };
-  return await sendRequest(info, request);
-}
-
-async function ensureDaemon(): Promise<DaemonInfo> {
-  const existing = readDaemonInfo();
-  const localVersion = readVersion();
-  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();
-  }
-
-  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 < timeoutMs) {
-    const info = readDaemonInfo();
-    if (info && (await canConnect(info))) return info;
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  return null;
-}
-
-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> {
-  await stopProcessForTakeover(info.pid, {
-    termTimeoutMs: DAEMON_TAKEOVER_TERM_TIMEOUT_MS,
-    killTimeoutMs: DAEMON_TAKEOVER_KILL_TIMEOUT_MS,
-    expectedStartTime: info.processStartTime,
-  });
-}
-
-function readDaemonInfo(): DaemonInfo | 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 {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown;
-  } catch {
-    return null;
-  }
-}
-
-function removeFileIfExists(filePath: string): void {
-  try {
-    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
-  } catch {
-    // Best-effort cleanup only.
-  }
-}
-
-async function canConnect(info: DaemonInfo): Promise<boolean> {
-  return new Promise((resolve) => {
-    const socket = net.createConnection({ host: '127.0.0.1', port: info.port }, () => {
-      socket.destroy();
-      resolve(true);
-    });
-    socket.on('error', () => {
-      resolve(false);
-    });
-  });
-}
-
-async function startDaemon(): Promise<void> {
-  const root = findProjectRoot();
-  const distPath = path.join(root, 'dist', 'src', 'daemon.js');
-  const srcPath = path.join(root, 'src', 'daemon.ts');
-
-  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 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);
-}
-
-async function sendRequest(info: DaemonInfo, req: DaemonRequest): Promise<DaemonResponse> {
-  return new Promise((resolve, reject) => {
-    const socket = net.createConnection({ host: '127.0.0.1', port: info.port }, () => {
-      socket.write(`${JSON.stringify(req)}\n`);
-    });
-    const timeout = setTimeout(() => {
-      socket.destroy();
-      reject(
-        new AppError('COMMAND_FAILED', 'Daemon request timed out', { timeoutMs: REQUEST_TIMEOUT_MS }),
-      );
-    }, REQUEST_TIMEOUT_MS);
-
-    let buffer = '';
-    socket.setEncoding('utf8');
-    socket.on('data', (chunk) => {
-      buffer += chunk;
-      const idx = buffer.indexOf('\n');
-      if (idx === -1) return;
-      const line = buffer.slice(0, idx).trim();
-      if (!line) return;
-      try {
-        const response = JSON.parse(line) as DaemonResponse;
-        socket.end();
-        clearTimeout(timeout);
-        resolve(response);
-      } catch (err) {
-        clearTimeout(timeout);
-        reject(err);
-      }
-    });
-
-    socket.on('error', (err) => {
-      clearTimeout(timeout);
-      reject(err);
-    });
-  });
-}
-
-export function resolveDaemonRequestTimeoutMs(raw: string | undefined = process.env.AGENT_DEVICE_DAEMON_TIMEOUT_MS): number {
-  if (!raw) return 90000;
-  const parsed = Number(raw);
-  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.';
-}

package/src/daemon.ts

@@ -1,295 +0,0 @@
-import net from 'node:net';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import crypto from 'node:crypto';
-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 { 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';
-import { handleSessionCommands } from './daemon/handlers/session.ts';
-import { handleSnapshotCommands } from './daemon/handlers/snapshot.ts';
-import { handleFindCommands } from './daemon/handlers/find.ts';
-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);
-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,
-  traceLogPath?: string,
-): DaemonCommandContext {
-  return contextFromFlagsWithLog(logPath, flags, appBundleId, traceLogPath);
-}
-
-async function handleRequest(req: DaemonRequest): Promise<DaemonResponse> {
-  if (req.token !== token) {
-    return { ok: false, error: { code: 'UNAUTHORIZED', message: 'Invalid token' } };
-  }
-
-  const command = req.command;
-  const sessionName = resolveEffectiveSessionName(req, sessionStore);
-  const existingSession = sessionStore.get(sessionName);
-  if (existingSession && !selectorValidationExemptCommands.has(command)) {
-    assertSessionSelectorMatches(existingSession, req.flags);
-  }
-
-  const sessionResponse = await handleSessionCommands({
-    req,
-    sessionName,
-    logPath,
-    sessionStore,
-    invoke: handleRequest,
-  });
-  if (sessionResponse) return sessionResponse;
-
-  const snapshotResponse = await handleSnapshotCommands({
-    req,
-    sessionName,
-    logPath,
-    sessionStore,
-  });
-  if (snapshotResponse) return snapshotResponse;
-
-  const recordTraceResponse = await handleRecordTraceCommands({
-    req,
-    sessionName,
-    sessionStore,
-  });
-  if (recordTraceResponse) return recordTraceResponse;
-
-  const findResponse = await handleFindCommands({
-    req,
-    sessionName,
-    logPath,
-    sessionStore,
-    invoke: handleRequest,
-  });
-  if (findResponse) return findResponse;
-
-  const interactionResponse = await handleInteractionCommands({
-    req,
-    sessionName,
-    sessionStore,
-    contextFromFlags,
-  });
-  if (interactionResponse) return interactionResponse;
-
-
-  const session = sessionStore.get(sessionName);
-  if (!session) {
-    return {
-      ok: false,
-      error: { code: 'SESSION_NOT_FOUND', message: 'No active session. Run open first.' },
-    };
-  }
-
-  if (!isCommandSupportedOnDevice(command, session.device)) {
-    return {
-      ok: false,
-      error: { code: 'UNSUPPORTED_OPERATION', message: `${command} is not supported on this device` },
-    };
-  }
-
-  const data = await dispatchCommand(session.device, command, req.positionals ?? [], req.flags?.out, {
-    ...contextFromFlags(req.flags, session.appBundleId, session.trace?.outPath),
-  });
-  sessionStore.recordAction(session, {
-    command,
-    positionals: req.positionals ?? [],
-    flags: req.flags ?? {},
-    result: data ?? {},
-  });
-  return { ok: true, data: data ?? {} };
-}
-
-function writeInfo(port: number): void {
-  if (!fs.existsSync(baseDir)) fs.mkdirSync(baseDir, { recursive: true });
-  fs.writeFileSync(logPath, '');
-  fs.writeFileSync(
-    infoPath,
-    JSON.stringify({ port, token, pid: process.pid, version, processStartTime: daemonProcessStartTime }, null, 2),
-    {
-      mode: 0o600,
-    },
-  );
-}
-
-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');
-    socket.on('data', async (chunk) => {
-      buffer += chunk;
-      let idx = buffer.indexOf('\n');
-      while (idx !== -1) {
-        const line = buffer.slice(0, idx).trim();
-        buffer = buffer.slice(idx + 1);
-        if (line.length === 0) {
-          idx = buffer.indexOf('\n');
-          continue;
-        }
-        let response: DaemonResponse;
-        try {
-          const req = JSON.parse(line) as DaemonRequest;
-          response = await handleRequest(req);
-        } catch (err) {
-          const appErr = asAppError(err);
-          response = {
-            ok: false,
-            error: { code: appErr.code, message: appErr.message, details: appErr.details },
-          };
-        }
-        socket.write(`${JSON.stringify(response)}\n`);
-        idx = buffer.indexOf('\n');
-      }
-    });
-  });
-
-  server.listen(0, '127.0.0.1', () => {
-    const address = server.address();
-    if (typeof address === 'object' && address?.port) {
-      writeInfo(address.port);
-      process.stdout.write(`AGENT_DEVICE_DAEMON_PORT=${address.port}\n`);
-    }
-  });
-
-  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();
-    removeInfo();
-    releaseDaemonLock();
-    process.exit(0);
-  };
-
-  process.on('SIGINT', () => {
-    void shutdown();
-  });
-  process.on('SIGTERM', () => {
-    void shutdown();
-  });
-  process.on('SIGHUP', () => {
-    void shutdown();
-  });
-  process.on('uncaughtException', (err) => {
-    const appErr = err instanceof AppError ? err : asAppError(err);
-    process.stderr.write(`Daemon error: ${appErr.message}\n`);
-    void shutdown();
-  });
-}
-
-start();

package/src/platforms/__tests__/boot-diagnostics.test.ts

@@ -1,59 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { bootFailureHint, classifyBootFailure } from '../boot-diagnostics.ts';
-import { AppError } from '../../utils/errors.ts';
-
-test('classifyBootFailure maps timeout errors', () => {
-  const reason = classifyBootFailure({
-    message: 'bootstatus timed out after 120s',
-    context: { platform: 'ios', phase: 'boot' },
-  });
-  assert.equal(reason, 'IOS_BOOT_TIMEOUT');
-});
-
-test('classifyBootFailure maps adb offline errors', () => {
-  const reason = classifyBootFailure({
-    stderr: 'error: device offline',
-    context: { platform: 'android', phase: 'transport' },
-  });
-  assert.equal(reason, 'ADB_TRANSPORT_UNAVAILABLE');
-});
-
-test('classifyBootFailure maps tool missing from AppError code (android)', () => {
-  const reason = classifyBootFailure({
-    error: new AppError('TOOL_MISSING', 'adb not found in PATH'),
-    context: { platform: 'android', phase: 'transport' },
-  });
-  assert.equal(reason, 'ADB_TRANSPORT_UNAVAILABLE');
-});
-
-test('classifyBootFailure maps tool missing from AppError code (ios)', () => {
-  const reason = classifyBootFailure({
-    error: new AppError('TOOL_MISSING', 'xcrun not found in PATH'),
-    context: { platform: 'ios', phase: 'boot' },
-  });
-  assert.equal(reason, 'IOS_TOOL_MISSING');
-});
-
-test('classifyBootFailure reads stderr from AppError details', () => {
-  const reason = classifyBootFailure({
-    error: new AppError('COMMAND_FAILED', 'adb failed', {
-      stderr: 'error: device unauthorized',
-    }),
-    context: { platform: 'android', phase: 'transport' },
-  });
-  assert.equal(reason, 'ADB_TRANSPORT_UNAVAILABLE');
-});
-
-test('bootFailureHint returns actionable guidance', () => {
-  const hint = bootFailureHint('IOS_RUNNER_CONNECT_TIMEOUT');
-  assert.equal(hint.includes('xcodebuild logs'), true);
-});
-
-test('connect phase does not classify non-timeout errors as connect timeout', () => {
-  const reason = classifyBootFailure({
-    message: 'Runner returned malformed JSON payload',
-    context: { platform: 'ios', phase: 'connect' },
-  });
-  assert.equal(reason, 'BOOT_COMMAND_FAILED');
-});