agent-device 0.2.6 → 0.3.0

package/src/platforms/android/ui-hierarchy.ts

@@ -0,0 +1,312 @@
+import type { RawSnapshotNode, Rect, SnapshotOptions } from '../../utils/snapshot.ts';
+
+export function findBounds(xml: string, query: string): { x: number; y: number } | null {
+  const q = query.toLowerCase();
+  const nodeRegex = /<node[^>]+>/g;
+  let match = nodeRegex.exec(xml);
+  while (match) {
+    const node = match[0];
+    const attrs = parseXmlNodeAttributes(node);
+    const textVal = (readXmlAttr(attrs, 'text') ?? '').toLowerCase();
+    const descVal = (readXmlAttr(attrs, 'content-desc') ?? '').toLowerCase();
+    if (textVal.includes(q) || descVal.includes(q)) {
+      const rect = parseBounds(readXmlAttr(attrs, 'bounds'));
+      if (rect) {
+        return {
+          x: Math.floor(rect.x + rect.width / 2),
+          y: Math.floor(rect.y + rect.height / 2),
+        };
+      }
+      return { x: 0, y: 0 };
+    }
+    match = nodeRegex.exec(xml);
+  }
+  return null;
+}
+
+export function parseUiHierarchy(
+  xml: string,
+  maxNodes: number,
+  options: SnapshotOptions,
+): { nodes: RawSnapshotNode[]; truncated?: boolean } {
+  const tree = parseUiHierarchyTree(xml);
+  const nodes: RawSnapshotNode[] = [];
+  let truncated = false;
+  const maxDepth = options.depth ?? Number.POSITIVE_INFINITY;
+  const scopedRoot = options.scope ? findScopeNode(tree, options.scope) : null;
+  const roots = scopedRoot ? [scopedRoot] : tree.children;
+
+  const interactiveDescendantMemo = new Map<AndroidNode, boolean>();
+  const hasInteractiveDescendant = (node: AndroidNode): boolean => {
+    const cached = interactiveDescendantMemo.get(node);
+    if (cached !== undefined) return cached;
+    for (const child of node.children) {
+      if (child.hittable || hasInteractiveDescendant(child)) {
+        interactiveDescendantMemo.set(node, true);
+        return true;
+      }
+    }
+    interactiveDescendantMemo.set(node, false);
+    return false;
+  };
+
+  const walk = (
+    node: AndroidNode,
+    depth: number,
+    parentIndex?: number,
+    ancestorHittable: boolean = false,
+    ancestorCollection: boolean = false,
+  ) => {
+    if (nodes.length >= maxNodes) {
+      truncated = true;
+      return;
+    }
+    if (depth > maxDepth) return;
+
+    const include = options.raw
+      ? true
+      : shouldIncludeAndroidNode(
+          node,
+          options,
+          ancestorHittable,
+          hasInteractiveDescendant(node),
+          ancestorCollection,
+        );
+    let currentIndex = parentIndex;
+    if (include) {
+      currentIndex = nodes.length;
+      nodes.push({
+        index: currentIndex,
+        type: node.type ?? undefined,
+        label: node.label ?? undefined,
+        value: node.value ?? undefined,
+        identifier: node.identifier ?? undefined,
+        rect: node.rect,
+        enabled: node.enabled,
+        hittable: node.hittable,
+        depth,
+        parentIndex,
+      });
+    }
+    const nextAncestorHittable = ancestorHittable || Boolean(node.hittable);
+    const nextAncestorCollection = ancestorCollection || isCollectionContainerType(node.type);
+    for (const child of node.children) {
+      walk(child, depth + 1, currentIndex, nextAncestorHittable, nextAncestorCollection);
+      if (truncated) return;
+    }
+  };
+
+  for (const root of roots) {
+    walk(root, 0, undefined, false, false);
+    if (truncated) break;
+  }
+
+  return truncated ? { nodes, truncated } : { nodes };
+}
+
+export function readNodeAttributes(node: string): {
+  text: string | null;
+  desc: string | null;
+  resourceId: string | null;
+  className: string | null;
+  bounds: string | null;
+  clickable?: boolean;
+  enabled?: boolean;
+  focusable?: boolean;
+  focused?: boolean;
+} {
+  const attrs = parseXmlNodeAttributes(node);
+  const getAttr = (name: string): string | null => readXmlAttr(attrs, name);
+  const boolAttr = (name: string): boolean | undefined => {
+    const raw = getAttr(name);
+    if (raw === null) return undefined;
+    return raw === 'true';
+  };
+  return {
+    text: getAttr('text'),
+    desc: getAttr('content-desc'),
+    resourceId: getAttr('resource-id'),
+    className: getAttr('class'),
+    bounds: getAttr('bounds'),
+    clickable: boolAttr('clickable'),
+    enabled: boolAttr('enabled'),
+    focusable: boolAttr('focusable'),
+    focused: boolAttr('focused'),
+  };
+}
+
+function parseXmlNodeAttributes(node: string): Map<string, string> {
+  const attrs = new Map<string, string>();
+  const start = node.indexOf(' ');
+  const end = node.lastIndexOf('>');
+  if (start < 0 || end <= start) return attrs;
+
+  const attrRegex = /([^\s=/>]+)\s*=\s*(["'])([\s\S]*?)\2/y;
+  let cursor = start;
+  while (cursor < end) {
+    while (cursor < end) {
+      const char = node[cursor];
+      if (char !== ' ' && char !== '\n' && char !== '\r' && char !== '\t') break;
+      cursor += 1;
+    }
+    if (cursor >= end) break;
+    const char = node[cursor];
+    if (char === '/' || char === '>') break;
+
+    attrRegex.lastIndex = cursor;
+    const match = attrRegex.exec(node);
+    if (!match) break;
+    attrs.set(match[1], match[3]);
+    cursor = attrRegex.lastIndex;
+  }
+
+  return attrs;
+}
+
+function readXmlAttr(attrs: Map<string, string>, name: string): string | null {
+  return attrs.get(name) ?? null;
+}
+
+export function parseBounds(bounds: string | null): Rect | undefined {
+  if (!bounds) return undefined;
+  const match = /\[(\d+),(\d+)\]\[(\d+),(\d+)\]/.exec(bounds);
+  if (!match) return undefined;
+  const x1 = Number(match[1]);
+  const y1 = Number(match[2]);
+  const x2 = Number(match[3]);
+  const y2 = Number(match[4]);
+  return { x: x1, y: y1, width: Math.max(0, x2 - x1), height: Math.max(0, y2 - y1) };
+}
+
+type AndroidNode = {
+  type: string | null;
+  label: string | null;
+  value: string | null;
+  identifier: string | null;
+  rect?: Rect;
+  enabled?: boolean;
+  hittable?: boolean;
+  depth: number;
+  parentIndex?: number;
+  children: AndroidNode[];
+};
+
+function parseUiHierarchyTree(xml: string): AndroidNode {
+  const root: AndroidNode = {
+    type: null,
+    label: null,
+    value: null,
+    identifier: null,
+    depth: -1,
+    children: [],
+  };
+  const stack: AndroidNode[] = [root];
+  const tokenRegex = /<node\b[^>]*>|<\/node>/g;
+  let match = tokenRegex.exec(xml);
+  while (match) {
+    const token = match[0];
+    if (token.startsWith('</node')) {
+      if (stack.length > 1) stack.pop();
+      match = tokenRegex.exec(xml);
+      continue;
+    }
+    const attrs = readNodeAttributes(token);
+    const rect = parseBounds(attrs.bounds);
+    const parent = stack[stack.length - 1];
+    const node: AndroidNode = {
+      type: attrs.className,
+      label: attrs.text || attrs.desc,
+      value: attrs.text,
+      identifier: attrs.resourceId,
+      rect,
+      enabled: attrs.enabled,
+      hittable: attrs.clickable ?? attrs.focusable,
+      depth: parent.depth + 1,
+      parentIndex: undefined,
+      children: [],
+    };
+    parent.children.push(node);
+    if (!token.endsWith('/>')) {
+      stack.push(node);
+    }
+    match = tokenRegex.exec(xml);
+  }
+  return root;
+}
+
+function shouldIncludeAndroidNode(
+  node: AndroidNode,
+  options: SnapshotOptions,
+  ancestorHittable: boolean,
+  descendantHittable: boolean,
+  ancestorCollection: boolean,
+): boolean {
+  const type = normalizeAndroidType(node.type);
+  const hasText = Boolean(node.label && node.label.trim().length > 0);
+  const hasId = Boolean(node.identifier && node.identifier.trim().length > 0);
+  const hasMeaningfulText = hasText && !isGenericAndroidId(node.label ?? '');
+  const hasMeaningfulId = hasId && !isGenericAndroidId(node.identifier ?? '');
+  const isStructural = isStructuralAndroidType(type);
+  const isVisual = type === 'imageview' || type === 'imagebutton';
+  if (options.interactiveOnly) {
+    if (node.hittable) return true;
+    // Keep text proxies for tappable rows while dropping structural noise.
+    const proxyCandidate = hasMeaningfulText || hasMeaningfulId;
+    if (!proxyCandidate) return false;
+    if (isVisual) return false;
+    if (isStructural && !ancestorCollection) return false;
+    return ancestorHittable || descendantHittable || ancestorCollection;
+  }
+  if (options.compact) {
+    return hasMeaningfulText || hasMeaningfulId || Boolean(node.hittable);
+  }
+  if (isStructural || isVisual) {
+    if (node.hittable) return true;
+    if (hasMeaningfulText) return true;
+    if (hasMeaningfulId && descendantHittable) return true;
+    return descendantHittable;
+  }
+  return true;
+}
+
+function isCollectionContainerType(type: string | null): boolean {
+  if (!type) return false;
+  const normalized = normalizeAndroidType(type);
+  return (
+    normalized.includes('recyclerview') ||
+    normalized.includes('listview') ||
+    normalized.includes('gridview')
+  );
+}
+
+function normalizeAndroidType(type: string | null): string {
+  if (!type) return '';
+  return type.toLowerCase();
+}
+
+function isStructuralAndroidType(type: string): boolean {
+  const short = type.split('.').pop() ?? type;
+  return short.includes('layout') || short === 'viewgroup' || short === 'view';
+}
+
+function isGenericAndroidId(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  return /^[\w.]+:id\/[\w.-]+$/i.test(trimmed);
+}
+
+function findScopeNode(root: AndroidNode, scope: string): AndroidNode | null {
+  const query = scope.toLowerCase();
+  const stack: AndroidNode[] = [...root.children];
+  while (stack.length > 0) {
+    const node = stack.shift() as AndroidNode;
+    const label = node.label?.toLowerCase() ?? '';
+    const value = node.value?.toLowerCase() ?? '';
+    const identifier = node.identifier?.toLowerCase() ?? '';
+    if (label.includes(query) || value.includes(query) || identifier.includes(query)) {
+      return node;
+    }
+    stack.push(...node.children);
+  }
+  return null;
+}

package/src/platforms/ios/runner-client.ts

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AppError } from '../../utils/errors.ts';
-import { runCmd, runCmdStreaming, type ExecResult } from '../../utils/exec.ts';
+import { runCmd, runCmdStreaming, runCmdBackground, type ExecResult, type ExecBackgroundResult } from '../../utils/exec.ts';
 import { withRetry } from '../../utils/retry.ts';
 import type { DeviceInfo } from '../../utils/device.ts';
 import net from 'node:net';
@@ -46,9 +46,30 @@ export type RunnerSession = {
   xctestrunPath: string;
   jsonPath: string;
   testPromise: Promise<ExecResult>;
+  child: ExecBackgroundResult['child'];
+  ready: boolean;
 };
 
 const runnerSessions = new Map<string, RunnerSession>();
+const RUNNER_STARTUP_TIMEOUT_MS = resolveTimeoutMs(
+  process.env.AGENT_DEVICE_RUNNER_STARTUP_TIMEOUT_MS,
+  120_000,
+  5_000,
+);
+const RUNNER_COMMAND_TIMEOUT_MS = resolveTimeoutMs(
+  process.env.AGENT_DEVICE_RUNNER_COMMAND_TIMEOUT_MS,
+  15_000,
+  1_000,
+);
+const RUNNER_STOP_WAIT_TIMEOUT_MS = 10_000;
+const RUNNER_SHUTDOWN_TIMEOUT_MS = 15_000;
+
+function resolveTimeoutMs(raw: string | undefined, fallback: number, min: number): number {
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(min, Math.floor(parsed));
+}
 
 export type RunnerSnapshotNode = {
   index: number;
@@ -87,29 +108,14 @@ async function executeRunnerCommand(
 
   try {
     const session = await ensureRunnerSession(device, options);
-    const response = await waitForRunner(device, session.port, command, options.logPath);
-    const text = await response.text();
-
-    let json: any = {};
-    try {
-      json = JSON.parse(text);
-    } catch {
-      throw new AppError('COMMAND_FAILED', 'Invalid runner response', { text });
-    }
-
-    if (!json.ok) {
-      throw new AppError('COMMAND_FAILED', json.error?.message ?? 'Runner error', {
-        runner: json,
-        xcodebuild: {
-          exitCode: 1,
-          stdout: '',
-          stderr: '',
-        },
-        logPath: options.logPath,
-      });
-    }
-
-    return json.data ?? {};
+    const timeoutMs = session.ready ? RUNNER_COMMAND_TIMEOUT_MS : RUNNER_STARTUP_TIMEOUT_MS;
+    return await executeRunnerCommandWithSession(
+      device,
+      session,
+      command,
+      options.logPath,
+      timeoutMs,
+    );
   } catch (err) {
     const appErr = err instanceof AppError ? err : new AppError('COMMAND_FAILED', String(err));
     if (
@@ -119,46 +125,79 @@ async function executeRunnerCommand(
     ) {
       await stopIosRunnerSession(device.id);
       const session = await ensureRunnerSession(device, options);
-      const response = await waitForRunner(device, session.port, command, options.logPath);
-      const text = await response.text();
-      let json: any = {};
-      try {
-        json = JSON.parse(text);
-      } catch {
-        throw new AppError('COMMAND_FAILED', 'Invalid runner response', { text });
-      }
-      if (!json.ok) {
-        throw new AppError('COMMAND_FAILED', json.error?.message ?? 'Runner error', {
-          runner: json,
-          xcodebuild: {
-            exitCode: 1,
-            stdout: '',
-            stderr: '',
-          },
-          logPath: options.logPath,
-        });
-      }
-      return json.data ?? {};
+      const response = await waitForRunner(
+        session.device,
+        session.port,
+        command,
+        options.logPath,
+        RUNNER_STARTUP_TIMEOUT_MS,
+      );
+      return await parseRunnerResponse(response, session, options.logPath);
     }
     throw err;
   }
 }
 
+async function executeRunnerCommandWithSession(
+  device: DeviceInfo,
+  session: RunnerSession,
+  command: RunnerCommand,
+  logPath: string | undefined,
+  timeoutMs: number,
+): Promise<Record<string, unknown>> {
+  const response = await waitForRunner(device, session.port, command, logPath, timeoutMs);
+  return await parseRunnerResponse(response, session, logPath);
+}
+
+async function parseRunnerResponse(
+  response: Response,
+  session: RunnerSession,
+  logPath?: string,
+): Promise<Record<string, unknown>> {
+  const text = await response.text();
+  let json: any = {};
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new AppError('COMMAND_FAILED', 'Invalid runner response', { text });
+  }
+  if (!json.ok) {
+    throw new AppError('COMMAND_FAILED', json.error?.message ?? 'Runner error', {
+      runner: json,
+      xcodebuild: {
+        exitCode: 1,
+        stdout: '',
+        stderr: '',
+      },
+      logPath,
+    });
+  }
+  session.ready = true;
+  return json.data ?? {};
+}
+
 export async function stopIosRunnerSession(deviceId: string): Promise<void> {
   const session = runnerSessions.get(deviceId);
   if (!session) return;
   try {
     await waitForRunner(session.device, session.port, {
       command: 'shutdown',
-    } as RunnerCommand);
+    } as RunnerCommand, undefined, RUNNER_SHUTDOWN_TIMEOUT_MS);
   } catch {
-    // ignore
+    // Runner not responsive — send SIGTERM so we don't hang on testPromise
+    await killRunnerProcessTree(session.child.pid, 'SIGTERM');
   }
   try {
-    await session.testPromise;
+    // Bound the wait so we never hang if xcodebuild refuses to exit
+    await Promise.race([
+      session.testPromise,
+      new Promise<void>((resolve) => setTimeout(resolve, RUNNER_STOP_WAIT_TIMEOUT_MS)),
+    ]);
   } catch {
     // ignore
   }
+  // Force-kill if still alive (harmless if already exited)
+  await killRunnerProcessTree(session.child.pid, 'SIGKILL');
   cleanupTempFile(session.xctestrunPath);
   cleanupTempFile(session.jsonPath);
   runnerSessions.delete(deviceId);
@@ -183,7 +222,7 @@ async function ensureRunnerSession(
     { AGENT_DEVICE_RUNNER_PORT: String(port) },
     `session-${device.id}-${port}`,
   );
-  const testPromise = runCmdStreaming(
+  const { child, wait: testPromise } = runCmdBackground(
     'xcodebuild',
     [
       'test-without-building',
@@ -201,16 +240,16 @@ async function ensureRunnerSession(
       `platform=iOS Simulator,id=${device.id}`,
     ],
     {
-      onStdoutChunk: (chunk) => {
-        logChunk(chunk, options.logPath, options.traceLogPath, options.verbose);
-      },
-      onStderrChunk: (chunk) => {
-        logChunk(chunk, options.logPath, options.traceLogPath, options.verbose);
-      },
       allowFailure: true,
       env: { ...process.env, AGENT_DEVICE_RUNNER_PORT: String(port) },
     },
   );
+  child.stdout?.on('data', (chunk: string) => {
+    logChunk(chunk, options.logPath, options.traceLogPath, options.verbose);
+  });
+  child.stderr?.on('data', (chunk: string) => {
+    logChunk(chunk, options.logPath, options.traceLogPath, options.verbose);
+  });
 
   const session: RunnerSession = {
     device,
@@ -219,11 +258,31 @@ async function ensureRunnerSession(
     xctestrunPath,
     jsonPath,
     testPromise,
+    child,
+    ready: false,
   };
   runnerSessions.set(device.id, session);
   return session;
 }
 
+async function killRunnerProcessTree(
+  pid: number | undefined,
+  signal: 'SIGTERM' | 'SIGKILL',
+): Promise<void> {
+  if (!pid || pid <= 0) return;
+  try {
+    process.kill(pid, signal);
+  } catch {
+    // ignore
+  }
+  const pkillSignal = signal === 'SIGTERM' ? 'TERM' : 'KILL';
+  try {
+    await runCmd('pkill', [`-${pkillSignal}`, '-P', String(pid)], { allowFailure: true });
+  } catch {
+    // ignore
+  }
+}
+
 
 async function ensureXctestrun(
   udid: string,
@@ -364,10 +423,11 @@ async function waitForRunner(
   port: number,
   command: RunnerCommand,
   logPath?: string,
+  timeoutMs: number = RUNNER_STARTUP_TIMEOUT_MS,
 ): Promise<Response> {
   const start = Date.now();
   let lastError: unknown = null;
-  while (Date.now() - start < 15000) {
+  while (Date.now() - start < timeoutMs) {
     try {
       const response = await fetch(`http://127.0.0.1:${port}/command`, {
         method: 'POST',