agent-device 0.4.2 → 0.5.0

package/src/daemon/handlers/__tests__/snapshot-handler.test.ts

@@ -1,92 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { handleSnapshotCommands } from '../snapshot.ts';
-import { SessionStore } from '../../session-store.ts';
-import type { SessionState } from '../../types.ts';
-
-function makeSessionStore(): SessionStore {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-snapshot-handler-'));
-  return new SessionStore(path.join(root, 'sessions'));
-}
-
-function makeSession(name: string, device: SessionState['device']): SessionState {
-  return {
-    name,
-    device,
-    createdAt: Date.now(),
-    actions: [],
-  };
-}
-
-test('snapshot rejects AX backend on iOS physical devices', async () => {
-  const sessionStore = makeSessionStore();
-  const sessionName = 'ios-device';
-  sessionStore.set(
-    sessionName,
-    makeSession(sessionName, {
-      platform: 'ios',
-      id: 'ios-device-1',
-      name: 'My iPhone',
-      kind: 'device',
-      booted: true,
-    }),
-  );
-
-  const response = await handleSnapshotCommands({
-    req: {
-      token: 't',
-      session: sessionName,
-      command: 'snapshot',
-      positionals: [],
-      flags: { snapshotBackend: 'ax' },
-    },
-    sessionName,
-    logPath: '/tmp/daemon.log',
-    sessionStore,
-  });
-
-  assert.ok(response);
-  assert.equal(response?.ok, false);
-  if (response && !response.ok) {
-    assert.equal(response.error.code, 'UNSUPPORTED_OPERATION');
-    assert.match(response.error.message, /AX snapshot backend is not supported/i);
-  }
-});
-
-test('settings rejects unsupported iOS physical devices', async () => {
-  const sessionStore = makeSessionStore();
-  const sessionName = 'ios-device';
-  sessionStore.set(
-    sessionName,
-    makeSession(sessionName, {
-      platform: 'ios',
-      id: 'ios-device-1',
-      name: 'My iPhone',
-      kind: 'device',
-      booted: true,
-    }),
-  );
-
-  const response = await handleSnapshotCommands({
-    req: {
-      token: 't',
-      session: sessionName,
-      command: 'settings',
-      positionals: ['wifi', 'on'],
-      flags: {},
-    },
-    sessionName,
-    logPath: '/tmp/daemon.log',
-    sessionStore,
-  });
-
-  assert.ok(response);
-  assert.equal(response?.ok, false);
-  if (response && !response.ok) {
-    assert.equal(response.error.code, 'UNSUPPORTED_OPERATION');
-    assert.match(response.error.message, /settings is not supported/i);
-  }
-});

package/src/daemon/handlers/__tests__/snapshot.test.ts

@@ -1,128 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { parseWaitArgs } from '../snapshot.ts';
-import { parseTimeout } from '../parse-utils.ts';
-
-// --- parseTimeout ---
-
-test('parseTimeout parses integer string', () => {
-  assert.equal(parseTimeout('500'), 500);
-});
-
-test('parseTimeout parses zero', () => {
-  assert.equal(parseTimeout('0'), 0);
-});
-
-test('parseTimeout returns null for non-numeric string', () => {
-  assert.equal(parseTimeout('abc'), null);
-});
-
-test('parseTimeout returns null for Infinity', () => {
-  assert.equal(parseTimeout('Infinity'), null);
-});
-
-// --- parseWaitArgs ---
-
-test('parseWaitArgs returns null for empty args', () => {
-  assert.equal(parseWaitArgs([]), null);
-});
-
-test('parseWaitArgs returns sleep for numeric first arg', () => {
-  const result = parseWaitArgs(['500']);
-  assert.deepEqual(result, { kind: 'sleep', durationMs: 500 });
-});
-
-test('parseWaitArgs returns sleep for zero', () => {
-  const result = parseWaitArgs(['0']);
-  assert.deepEqual(result, { kind: 'sleep', durationMs: 0 });
-});
-
-test('parseWaitArgs parses text keyword with label', () => {
-  const result = parseWaitArgs(['text', 'Loading']);
-  assert.deepEqual(result, { kind: 'text', text: 'Loading', timeoutMs: null });
-});
-
-test('parseWaitArgs parses text keyword with timeout', () => {
-  const result = parseWaitArgs(['text', 'Loading', '5000']);
-  assert.deepEqual(result, { kind: 'text', text: 'Loading', timeoutMs: 5000 });
-});
-
-test('parseWaitArgs parses text keyword with multi-word and timeout', () => {
-  const result = parseWaitArgs(['text', 'Sign', 'In', '3000']);
-  assert.deepEqual(result, { kind: 'text', text: 'Sign In', timeoutMs: 3000 });
-});
-
-test('parseWaitArgs parses text keyword with multi-word and no timeout', () => {
-  const result = parseWaitArgs(['text', 'Sign', 'In']);
-  assert.deepEqual(result, { kind: 'text', text: 'Sign In', timeoutMs: null });
-});
-
-test('parseWaitArgs text keyword alone yields empty text', () => {
-  const result = parseWaitArgs(['text']);
-  assert.deepEqual(result, { kind: 'text', text: '', timeoutMs: null });
-});
-
-test('parseWaitArgs parses ref', () => {
-  const result = parseWaitArgs(['@e3']);
-  assert.deepEqual(result, { kind: 'ref', rawRef: '@e3', timeoutMs: null });
-});
-
-test('parseWaitArgs parses ref with timeout', () => {
-  const result = parseWaitArgs(['@e3', '5000']);
-  assert.deepEqual(result, { kind: 'ref', rawRef: '@e3', timeoutMs: 5000 });
-});
-
-test('parseWaitArgs parses ref with non-numeric trailing arg as no timeout', () => {
-  const result = parseWaitArgs(['@e3', 'abc']);
-  assert.deepEqual(result, { kind: 'ref', rawRef: '@e3', timeoutMs: null });
-});
-
-test('parseWaitArgs parses bare text', () => {
-  const result = parseWaitArgs(['Hello']);
-  assert.deepEqual(result, { kind: 'text', text: 'Hello', timeoutMs: null });
-});
-
-test('parseWaitArgs parses bare text with timeout', () => {
-  const result = parseWaitArgs(['Hello', '5000']);
-  assert.deepEqual(result, { kind: 'text', text: 'Hello', timeoutMs: 5000 });
-});
-
-test('parseWaitArgs parses selector expression', () => {
-  const result = parseWaitArgs(['id=login_email']);
-  assert.ok(result);
-  assert.equal(result.kind, 'selector');
-  if (result.kind === 'selector') {
-    assert.equal(result.selectorExpression, 'id=login_email');
-    assert.equal(result.timeoutMs, null);
-  }
-});
-
-test('parseWaitArgs parses selector expression with timeout', () => {
-  const result = parseWaitArgs(['id=login_email', '5000']);
-  assert.ok(result);
-  assert.equal(result.kind, 'selector');
-  if (result.kind === 'selector') {
-    assert.equal(result.selectorExpression, 'id=login_email');
-    assert.equal(result.timeoutMs, 5000);
-  }
-});
-
-test('parseWaitArgs falls back to text when selector-like token is invalid', () => {
-  const result = parseWaitArgs(['foo=bar', '5000']);
-  assert.deepEqual(result, { kind: 'text', text: 'foo=bar', timeoutMs: 5000 });
-});
-
-test('parseWaitArgs parses bare multi-word text', () => {
-  const result = parseWaitArgs(['Sign', 'In']);
-  assert.deepEqual(result, { kind: 'text', text: 'Sign In', timeoutMs: null });
-});
-
-test('parseWaitArgs parses bare multi-word text with timeout', () => {
-  const result = parseWaitArgs(['Sign', 'In', '3000']);
-  assert.deepEqual(result, { kind: 'text', text: 'Sign In', timeoutMs: 3000 });
-});
-
-test('parseWaitArgs text keyword with non-numeric trailing leaves timeoutMs null', () => {
-  const result = parseWaitArgs(['text', 'Loading', 'abc']);
-  assert.deepEqual(result, { kind: 'text', text: 'Loading abc', timeoutMs: null });
-});

package/src/daemon/handlers/find.ts

@@ -1,324 +0,0 @@
-import { dispatchCommand, resolveTargetDevice } from '../../core/dispatch.ts';
-import { findBestMatchesByLocator, type FindLocator } from '../../utils/finders.ts';
-import { attachRefs, centerOfRect, type RawSnapshotNode, type SnapshotState } from '../../utils/snapshot.ts';
-import { AppError } from '../../utils/errors.ts';
-import type { DaemonRequest, DaemonResponse } from '../types.ts';
-import { SessionStore } from '../session-store.ts';
-import { contextFromFlags } from '../context.ts';
-import { ensureDeviceReady } from '../device-ready.ts';
-import {
-  extractNodeText,
-  findNearestHittableAncestor,
-  pruneGroupNodes,
-} from '../snapshot-processing.ts';
-import { parseTimeout } from './parse-utils.ts';
-
-export async function handleFindCommands(params: {
-  req: DaemonRequest;
-  sessionName: string;
-  logPath: string;
-  sessionStore: SessionStore;
-  invoke: (req: DaemonRequest) => Promise<DaemonResponse>;
-}): Promise<DaemonResponse | null> {
-  const { req, sessionName, logPath, sessionStore, invoke } = params;
-  const command = req.command;
-  if (command !== 'find') return null;
-
-  const args = req.positionals ?? [];
-  if (args.length === 0) {
-    return { ok: false, error: { code: 'INVALID_ARGS', message: 'find requires a locator or text' } };
-  }
-  const { locator, query, action, value, timeoutMs } = parseFindArgs(args);
-  if (!query) {
-    return { ok: false, error: { code: 'INVALID_ARGS', message: 'find requires a value' } };
-  }
-  const session = sessionStore.get(sessionName);
-  const isReadOnly = action === 'exists' || action === 'wait' || action === 'get_text' || action === 'get_attrs';
-  if (!session && !isReadOnly) {
-    return {
-      ok: false,
-      error: { code: 'SESSION_NOT_FOUND', message: 'No active session. Run open first.' },
-    };
-  }
-  const device = session?.device ?? (await resolveTargetDevice(req.flags ?? {}));
-  if (!session) {
-    await ensureDeviceReady(device);
-  }
-  const appBundleId = session?.appBundleId;
-  const scope = shouldScopeFind(locator) ? query : undefined;
-  const requiresRect = action === 'click' || action === 'focus' || action === 'fill' || action === 'type';
-  const interactiveOnly = requiresRect;
-  let lastSnapshotAt = 0;
-  let lastNodes: SnapshotState['nodes'] | null = null;
-  const fetchNodes = async (): Promise<{
-    nodes: SnapshotState['nodes'];
-    truncated?: boolean;
-    backend?: SnapshotState['backend'];
-  }> => {
-    const now = Date.now();
-    if (lastNodes && now - lastSnapshotAt < 750) {
-      return { nodes: lastNodes };
-    }
-    const data = (await dispatchCommand(device, 'snapshot', [], req.flags?.out, {
-      ...contextFromFlags(
-        logPath,
-        {
-          ...req.flags,
-          snapshotScope: scope,
-          snapshotInteractiveOnly: interactiveOnly,
-          snapshotCompact: interactiveOnly,
-        },
-        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));
-    lastSnapshotAt = now;
-    lastNodes = nodes;
-    if (session) {
-      const snapshot: SnapshotState = {
-        nodes,
-        truncated: data?.truncated,
-        createdAt: Date.now(),
-        backend: data?.backend,
-      };
-      session.snapshot = snapshot;
-      sessionStore.set(sessionName, session);
-    }
-    return { nodes, truncated: data?.truncated, backend: data?.backend };
-  };
-  if (action === 'wait') {
-    const timeout = timeoutMs ?? 10000;
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      const { nodes } = await fetchNodes();
-      const match = findBestMatchesByLocator(nodes, locator, query, { requireRect: false }).matches[0];
-      if (match) {
-        if (session) {
-          sessionStore.recordAction(session, {
-            command,
-            positionals: req.positionals ?? [],
-            flags: req.flags ?? {},
-            result: { found: true, waitedMs: Date.now() - start },
-          });
-        }
-        return { ok: true, data: { found: true, waitedMs: Date.now() - start } };
-      }
-      await new Promise((resolve) => setTimeout(resolve, 300));
-    }
-    return { ok: false, error: { code: 'COMMAND_FAILED', message: 'find wait timed out' } };
-  }
-  const { nodes } = await fetchNodes();
-  const bestMatches = findBestMatchesByLocator(nodes, locator, query, { requireRect: requiresRect });
-  if (requiresRect && bestMatches.matches.length > 1) {
-    const candidates = bestMatches.matches.slice(0, 8).map((candidate) => {
-      const label = extractNodeText(candidate) || candidate.label || candidate.identifier || candidate.type || '';
-      return `@${candidate.ref}${label ? `(${label})` : ''}`;
-    });
-    return {
-      ok: false,
-      error: {
-        code: 'AMBIGUOUS_MATCH',
-        message: `find matched ${bestMatches.matches.length} elements for ${locator} "${query}". Use a more specific locator or selector.`,
-        details: {
-          locator,
-          query,
-          matches: bestMatches.matches.length,
-          candidates,
-        },
-      },
-    };
-  }
-  const node = bestMatches.matches[0] ?? null;
-  if (!node) {
-    return { ok: false, error: { code: 'COMMAND_FAILED', message: 'find did not match any element' } };
-  }
-  const resolvedNode =
-    action === 'click' || action === 'focus' || action === 'fill' || action === 'type'
-      ? findNearestHittableAncestor(nodes, node) ?? node
-      : node;
-  const ref = `@${resolvedNode.ref}`;
-  const actionFlags = { ...(req.flags ?? {}), noRecord: true };
-  if (action === 'exists') {
-    if (session) {
-      sessionStore.recordAction(session, {
-        command,
-        positionals: req.positionals ?? [],
-        flags: req.flags ?? {},
-        result: { found: true },
-      });
-    }
-    return { ok: true, data: { found: true } };
-  }
-  if (action === 'get_text') {
-    const text = extractNodeText(node);
-    if (session) {
-      sessionStore.recordAction(session, {
-        command,
-        positionals: req.positionals ?? [],
-        flags: req.flags ?? {},
-        result: { ref, action: 'get text', text },
-      });
-    }
-    return { ok: true, data: { ref, text, node } };
-  }
-  if (action === 'get_attrs') {
-    if (session) {
-      sessionStore.recordAction(session, {
-        command,
-        positionals: req.positionals ?? [],
-        flags: req.flags ?? {},
-        result: { ref, action: 'get attrs' },
-      });
-    }
-    return { ok: true, data: { ref, node } };
-  }
-  if (action === 'click') {
-    const response = await invoke({
-      token: req.token,
-      session: sessionName,
-      command: 'click',
-      positionals: [ref],
-      flags: actionFlags,
-    });
-    if (!response.ok) return response;
-    if (session) {
-      sessionStore.recordAction(session, {
-        command,
-        positionals: req.positionals ?? [],
-        flags: req.flags ?? {},
-        result: { ref, action: 'click' },
-      });
-    }
-    return response;
-  }
-  if (action === 'fill') {
-    if (!value) {
-      return { ok: false, error: { code: 'INVALID_ARGS', message: 'find fill requires text' } };
-    }
-    const response = await invoke({
-      token: req.token,
-      session: sessionName,
-      command: 'fill',
-      positionals: [ref, value],
-      flags: actionFlags,
-    });
-    if (!response.ok) return response;
-    if (session) {
-      sessionStore.recordAction(session, {
-        command,
-        positionals: req.positionals ?? [],
-        flags: req.flags ?? {},
-        result: { ref, action: 'fill' },
-      });
-    }
-    return response;
-  }
-  if (action === 'focus') {
-    const coords = node.rect ? centerOfRect(node.rect) : null;
-    if (!coords) {
-      return { ok: false, error: { code: 'COMMAND_FAILED', message: 'matched element has no bounds' } };
-    }
-    const response = await dispatchCommand(device, 'focus', [String(coords.x), String(coords.y)], req.flags?.out, {
-      ...contextFromFlags(logPath, req.flags, session?.appBundleId, session?.trace?.outPath),
-    });
-    if (session) {
-      sessionStore.recordAction(session, {
-        command,
-        positionals: req.positionals ?? [],
-        flags: req.flags ?? {},
-        result: { ref, action: 'focus' },
-      });
-    }
-    return { ok: true, data: response ?? { ref } };
-  }
-  if (action === 'type') {
-    if (!value) {
-      return { ok: false, error: { code: 'INVALID_ARGS', message: 'find type requires text' } };
-    }
-    const coords = node.rect ? centerOfRect(node.rect) : null;
-    if (!coords) {
-      return { ok: false, error: { code: 'COMMAND_FAILED', message: 'matched element has no bounds' } };
-    }
-    await dispatchCommand(device, 'focus', [String(coords.x), String(coords.y)], req.flags?.out, {
-      ...contextFromFlags(logPath, req.flags, session?.appBundleId, session?.trace?.outPath),
-    });
-    const response = await dispatchCommand(device, 'type', [value], req.flags?.out, {
-      ...contextFromFlags(logPath, req.flags, session?.appBundleId, session?.trace?.outPath),
-    });
-    if (session) {
-      sessionStore.recordAction(session, {
-        command,
-        positionals: req.positionals ?? [],
-        flags: req.flags ?? {},
-        result: { ref, action: 'type' },
-      });
-    }
-    return { ok: true, data: response ?? { ref } };
-  }
-
-  return null;
-}
-
-type FindAction =
-  | { kind: 'click' }
-  | { kind: 'focus' }
-  | { kind: 'fill'; value: string }
-  | { kind: 'type'; value: string }
-  | { kind: 'get_text' }
-  | { kind: 'get_attrs' }
-  | { kind: 'exists' }
-  | { kind: 'wait'; timeoutMs?: number };
-
-export function parseFindArgs(args: string[]): {
-  locator: FindLocator;
-  query: string;
-  action: FindAction['kind'];
-  value?: string;
-  timeoutMs?: number;
-} {
-  const locatorTokens: FindLocator[] = ['text', 'label', 'value', 'role', 'id'];
-  let locator: FindLocator = 'any';
-  let queryIndex = 0;
-  if (locatorTokens.includes(args[0] as FindLocator)) {
-    locator = args[0] as FindLocator;
-    queryIndex = 1;
-  }
-  const query = args[queryIndex] ?? '';
-  const actionTokens = args.slice(queryIndex + 1);
-  if (actionTokens.length === 0) {
-    return { locator, query, action: 'click' };
-  }
-  const action = actionTokens[0].toLowerCase();
-  if (action === 'get') {
-    const sub = actionTokens[1]?.toLowerCase();
-    if (sub === 'text') return { locator, query, action: 'get_text' };
-    if (sub === 'attrs') return { locator, query, action: 'get_attrs' };
-    throw new AppError('INVALID_ARGS', 'find get only supports text or attrs');
-  }
-  if (action === 'wait') {
-    const timeoutMs = parseTimeout(actionTokens[1]);
-    return { locator, query, action: 'wait', timeoutMs: timeoutMs ?? undefined };
-  }
-  if (action === 'exists') return { locator, query, action: 'exists' };
-  if (action === 'click') return { locator, query, action: 'click' };
-  if (action === 'focus') return { locator, query, action: 'focus' };
-  if (action === 'fill') {
-    const value = actionTokens.slice(1).join(' ');
-    return { locator, query, action: 'fill', value };
-  }
-  if (action === 'type') {
-    const value = actionTokens.slice(1).join(' ');
-    return { locator, query, action: 'type', value };
-  }
-  throw new AppError('INVALID_ARGS', `Unsupported find action: ${actionTokens[0]}`);
-}
-
-function shouldScopeFind(locator: FindLocator): boolean {
-  return locator !== 'role';
-}