agent-device 0.2.4 → 0.2.6

package/src/daemon/handlers/__tests__/replay-heal.test.ts

@@ -0,0 +1,364 @@
+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 type { CommandFlags } from '../../../core/dispatch.ts';
+import { handleSessionCommands } from '../session.ts';
+import { SessionStore } from '../../session-store.ts';
+import type { DaemonRequest, DaemonResponse, SessionAction, SessionState } from '../../types.ts';
+import type { DeviceInfo } from '../../../utils/device.ts';
+
+function makeDevice(): DeviceInfo {
+  return {
+    platform: 'ios',
+    id: 'sim-1',
+    name: 'iPhone Test',
+    kind: 'simulator',
+    booted: true,
+  };
+}
+
+function makeSession(name: string): SessionState {
+  return {
+    name,
+    device: makeDevice(),
+    createdAt: Date.now(),
+    appBundleId: 'com.example.app',
+    actions: [],
+  };
+}
+
+function writeReplayFile(filePath: string, action: SessionAction) {
+  const args = action.positionals.map((value) => JSON.stringify(value)).join(' ');
+  fs.writeFileSync(filePath, `${action.command}${args.length > 0 ? ` ${args}` : ''}\n`);
+}
+
+function readReplaySelector(filePath: string, command: string): string {
+  const lines = fs
+    .readFileSync(filePath, 'utf8')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  const line = lines.find((entry) => entry.startsWith(`${command} `) || entry === command);
+  if (!line) return '';
+  const args = tokenizeReplayLine(line).slice(1);
+  if (command === 'is') {
+    return args[1] ?? '';
+  }
+  return args[0] ?? '';
+}
+
+function tokenizeReplayLine(line: string): string[] {
+  const tokens: string[] = [];
+  let cursor = 0;
+  while (cursor < line.length) {
+    while (cursor < line.length && /\s/.test(line[cursor])) {
+      cursor += 1;
+    }
+    if (cursor >= line.length) break;
+    if (line[cursor] === '"') {
+      let end = cursor + 1;
+      let escaped = false;
+      while (end < line.length) {
+        const char = line[end];
+        if (char === '"' && !escaped) break;
+        escaped = char === '\\' && !escaped;
+        if (char !== '\\') escaped = false;
+        end += 1;
+      }
+      if (end >= line.length) {
+        throw new Error(`Invalid replay script line: ${line}`);
+      }
+      tokens.push(JSON.parse(line.slice(cursor, end + 1)) as string);
+      cursor = end + 1;
+      continue;
+    }
+    let end = cursor;
+    while (end < line.length && !/\s/.test(line[end])) {
+      end += 1;
+    }
+    tokens.push(line.slice(cursor, end));
+    cursor = end;
+  }
+  return tokens;
+}
+
+test('replay --update heals selector and rewrites replay file', async () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-heal-'));
+  const sessionsDir = path.join(tempRoot, 'sessions');
+  const replayPath = path.join(tempRoot, 'replay.ad');
+  const sessionStore = new SessionStore(sessionsDir);
+  const sessionName = 'heal-session';
+  sessionStore.set(sessionName, makeSession(sessionName));
+
+  writeReplayFile(replayPath, {
+    ts: Date.now(),
+    command: 'click',
+    positionals: ['id="old_continue" || label="Continue"'],
+    flags: {},
+    result: {},
+  });
+
+  const invokeCalls: string[] = [];
+  const invoke = async (request: DaemonRequest): Promise<DaemonResponse> => {
+    if (request.command !== 'click') {
+      return { ok: false, error: { code: 'INVALID_ARGS', message: `unexpected command ${request.command}` } };
+    }
+    const selector = request.positionals?.[0] ?? '';
+    invokeCalls.push(selector);
+    if (selector.includes('old_continue')) {
+      return { ok: false, error: { code: 'COMMAND_FAILED', message: 'selector no longer exists' } };
+    }
+    if (selector.includes('auth_continue')) {
+      return { ok: true, data: { clicked: true } };
+    }
+    return { ok: false, error: { code: 'COMMAND_FAILED', message: 'unexpected selector' } };
+  };
+
+  let snapshotDispatchCalls = 0;
+  const dispatch = async (
+    _device: DeviceInfo,
+    command: string,
+    _positionals: string[],
+    _out?: string,
+    _context?: CommandFlags,
+  ): Promise<Record<string, unknown> | void> => {
+    if (command !== 'snapshot') {
+      throw new Error(`unexpected dispatch command: ${command}`);
+    }
+    snapshotDispatchCalls += 1;
+    return {
+      nodes: [
+        {
+          index: 0,
+          type: 'XCUIElementTypeButton',
+          label: 'Continue',
+          identifier: 'auth_continue',
+          rect: { x: 10, y: 10, width: 100, height: 44 },
+          enabled: true,
+          hittable: true,
+        },
+      ],
+      truncated: false,
+      backend: 'xctest',
+    };
+  };
+
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: sessionName,
+      command: 'replay',
+      positionals: [replayPath],
+      flags: { replayUpdate: true },
+    },
+    sessionName,
+    logPath: path.join(tempRoot, 'daemon.log'),
+    sessionStore,
+    invoke,
+    dispatch,
+  });
+
+  assert.ok(response);
+  assert.equal(response.ok, true, JSON.stringify(response));
+  if (response.ok) {
+    assert.equal(response.data?.healed, 1);
+    assert.equal(response.data?.replayed, 1);
+  }
+  assert.equal(snapshotDispatchCalls, 1);
+  assert.equal(invokeCalls.length, 2);
+  assert.ok(invokeCalls[0].includes('old_continue'));
+  assert.ok(invokeCalls[1].includes('auth_continue'));
+  const rewrittenSelector = readReplaySelector(replayPath, 'click');
+  assert.ok(rewrittenSelector.includes('auth_continue'));
+  assert.ok(!rewrittenSelector.includes('old_continue'));
+});
+
+test('replay without --update does not heal or rewrite', async () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-noheal-'));
+  const sessionsDir = path.join(tempRoot, 'sessions');
+  const replayPath = path.join(tempRoot, 'replay.ad');
+  const sessionStore = new SessionStore(sessionsDir);
+  const sessionName = 'noheal-session';
+  sessionStore.set(sessionName, makeSession(sessionName));
+
+  writeReplayFile(replayPath, {
+    ts: Date.now(),
+    command: 'click',
+    positionals: ['id="old_continue" || label="Continue"'],
+    flags: {},
+    result: {},
+  });
+  const originalPayload = fs.readFileSync(replayPath, 'utf8');
+
+  const invoke = async (_request: DaemonRequest): Promise<DaemonResponse> => {
+    return { ok: false, error: { code: 'COMMAND_FAILED', message: 'selector no longer exists' } };
+  };
+
+  let snapshotDispatchCalls = 0;
+  const dispatch = async (
+    _device: DeviceInfo,
+    _command: string,
+    _positionals: string[],
+    _out?: string,
+    _context?: CommandFlags,
+  ): Promise<Record<string, unknown> | void> => {
+    snapshotDispatchCalls += 1;
+    return {};
+  };
+
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: sessionName,
+      command: 'replay',
+      positionals: [replayPath],
+      flags: {},
+    },
+    sessionName,
+    logPath: path.join(tempRoot, 'daemon.log'),
+    sessionStore,
+    invoke,
+    dispatch,
+  });
+
+  assert.ok(response);
+  assert.equal(response.ok, false);
+  assert.equal(snapshotDispatchCalls, 0);
+  assert.equal(fs.readFileSync(replayPath, 'utf8'), originalPayload);
+});
+
+test('replay --update heals selector in is command', async () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-heal-is-'));
+  const sessionsDir = path.join(tempRoot, 'sessions');
+  const replayPath = path.join(tempRoot, 'replay.ad');
+  const sessionStore = new SessionStore(sessionsDir);
+  const sessionName = 'heal-is-session';
+  sessionStore.set(sessionName, makeSession(sessionName));
+
+  writeReplayFile(replayPath, {
+    ts: Date.now(),
+    command: 'is',
+    positionals: ['visible', 'id="old_continue" || label="Continue"'],
+    flags: {},
+    result: {},
+  });
+
+  const invoke = async (request: DaemonRequest): Promise<DaemonResponse> => {
+    if (request.command !== 'is') {
+      return { ok: false, error: { code: 'INVALID_ARGS', message: `unexpected command ${request.command}` } };
+    }
+    const selector = request.positionals?.[1] ?? '';
+    if (selector.includes('old_continue')) {
+      return { ok: false, error: { code: 'COMMAND_FAILED', message: 'selector stale' } };
+    }
+    if (selector.includes('auth_continue')) {
+      return { ok: true, data: { predicate: 'visible', pass: true } };
+    }
+    return { ok: false, error: { code: 'COMMAND_FAILED', message: 'unexpected selector' } };
+  };
+
+  const dispatch = async (): Promise<Record<string, unknown> | void> => {
+    return {
+      nodes: [
+        {
+          index: 0,
+          type: 'XCUIElementTypeButton',
+          label: 'Continue',
+          identifier: 'auth_continue',
+          rect: { x: 10, y: 10, width: 100, height: 44 },
+          enabled: true,
+          hittable: true,
+        },
+      ],
+      truncated: false,
+      backend: 'xctest',
+    };
+  };
+
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: sessionName,
+      command: 'replay',
+      positionals: [replayPath],
+      flags: { replayUpdate: true },
+    },
+    sessionName,
+    logPath: path.join(tempRoot, 'daemon.log'),
+    sessionStore,
+    invoke,
+    dispatch,
+  });
+
+  assert.ok(response);
+  assert.equal(response.ok, true, JSON.stringify(response));
+  if (response.ok) {
+    assert.equal(response.data?.healed, 1);
+  }
+  const rewrittenSelector = readReplaySelector(replayPath, 'is');
+  assert.ok(rewrittenSelector.includes('auth_continue'));
+});
+
+test('replay rejects legacy JSON payload files', async () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-json-rejected-'));
+  const sessionsDir = path.join(tempRoot, 'sessions');
+  const replayPath = path.join(tempRoot, 'replay.json');
+  const sessionStore = new SessionStore(sessionsDir);
+  const sessionName = 'json-rejected-session';
+  sessionStore.set(sessionName, makeSession(sessionName));
+  fs.writeFileSync(replayPath, JSON.stringify({ optimizedActions: [] }, null, 2));
+
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: sessionName,
+      command: 'replay',
+      positionals: [replayPath],
+      flags: {},
+    },
+    sessionName,
+    logPath: path.join(tempRoot, 'daemon.log'),
+    sessionStore,
+    invoke: async () => ({ ok: true, data: {} }),
+  });
+
+  assert.ok(response);
+  assert.equal(response.ok, false);
+  if (!response.ok) {
+    assert.equal(response.error.code, 'INVALID_ARGS');
+    assert.match(response.error.message, /\.ad script files/);
+  }
+});
+
+test('replay rejects malformed .ad lines with unclosed quotes', async () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-invalid-ad-'));
+  const sessionsDir = path.join(tempRoot, 'sessions');
+  const replayPath = path.join(tempRoot, 'replay.ad');
+  const sessionStore = new SessionStore(sessionsDir);
+  const sessionName = 'invalid-ad-session';
+  sessionStore.set(sessionName, makeSession(sessionName));
+  fs.writeFileSync(replayPath, 'click "id=\\"broken\\"\n');
+
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: sessionName,
+      command: 'replay',
+      positionals: [replayPath],
+      flags: {},
+    },
+    sessionName,
+    logPath: path.join(tempRoot, 'daemon.log'),
+    sessionStore,
+    invoke: async () => ({ ok: true, data: {} }),
+  });
+
+  assert.ok(response);
+  assert.equal(response.ok, false);
+  if (!response.ok) {
+    assert.equal(response.error.code, 'INVALID_ARGS');
+    assert.match(response.error.message, /Invalid replay script line/);
+  }
+});

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

@@ -0,0 +1,128 @@
+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 });
+});