agent-device 0.4.1 → 0.5.0

package/src/daemon/handlers/__tests__/session-reinstall.test.ts

@@ -1,219 +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 { handleSessionCommands } from '../session.ts';
-import { SessionStore } from '../../session-store.ts';
-import type { DaemonRequest, DaemonResponse, SessionState } from '../../types.ts';
-
-function makeStore(): SessionStore {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-session-reinstall-'));
-  return new SessionStore(path.join(tempRoot, 'sessions'));
-}
-
-function makeSession(name: string, device: SessionState['device']): SessionState {
-  return {
-    name,
-    device,
-    createdAt: Date.now(),
-    actions: [],
-  };
-}
-
-const invoke = async (_req: DaemonRequest): Promise<DaemonResponse> => {
-  return { ok: false, error: { code: 'INVALID_ARGS', message: 'invoke should not be called in reinstall tests' } };
-};
-
-test('reinstall requires active session or explicit device selector', async () => {
-  const sessionStore = makeStore();
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'reinstall',
-      positionals: ['com.example.app', '/tmp/app.apk'],
-      flags: {},
-    },
-    sessionName: 'default',
-    logPath: '/tmp/daemon.log',
-    sessionStore,
-    invoke,
-  });
-  assert.ok(response);
-  assert.equal(response.ok, false);
-  if (!response.ok) {
-    assert.equal(response.error.code, 'INVALID_ARGS');
-    assert.match(response.error.message, /active session or an explicit device selector/i);
-  }
-});
-
-test('reinstall validates required args before device operations', async () => {
-  const sessionStore = makeStore();
-  sessionStore.set(
-    'default',
-    makeSession('default', {
-      platform: 'ios',
-      id: 'sim-1',
-      name: 'iPhone',
-      kind: 'simulator',
-      booted: true,
-    }),
-  );
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'reinstall',
-      positionals: ['com.example.app'],
-      flags: {},
-    },
-    sessionName: 'default',
-    logPath: '/tmp/daemon.log',
-    sessionStore,
-    invoke,
-  });
-  assert.ok(response);
-  assert.equal(response.ok, false);
-  if (!response.ok) {
-    assert.equal(response.error.code, 'INVALID_ARGS');
-    assert.match(response.error.message, /reinstall <app> <path-to-app-binary>/i);
-  }
-});
-
-test('reinstall reports unsupported operation on iOS physical devices', async () => {
-  const sessionStore = makeStore();
-  sessionStore.set(
-    'default',
-    makeSession('default', {
-      platform: 'ios',
-      id: 'device-1',
-      name: 'iPhone Device',
-      kind: 'device',
-      booted: true,
-    }),
-  );
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-reinstall-binary-'));
-  const appPath = path.join(tempRoot, 'Sample.app');
-  fs.writeFileSync(appPath, 'placeholder');
-
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'reinstall',
-      positionals: ['com.example.app', appPath],
-      flags: {},
-    },
-    sessionName: 'default',
-    logPath: '/tmp/daemon.log',
-    sessionStore,
-    invoke,
-  });
-  assert.ok(response);
-  assert.equal(response.ok, false);
-  if (!response.ok) {
-    assert.equal(response.error.code, 'UNSUPPORTED_OPERATION');
-    assert.match(response.error.message, /reinstall is not supported/i);
-  }
-});
-
-test('reinstall succeeds on active iOS simulator session and records action', async () => {
-  const sessionStore = makeStore();
-  const session = makeSession('default', {
-    platform: 'ios',
-    id: 'sim-1',
-    name: 'iPhone',
-    kind: 'simulator',
-    booted: true,
-  });
-  sessionStore.set('default', session);
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-reinstall-success-ios-'));
-  const appPath = path.join(tempRoot, 'Sample.app');
-  fs.writeFileSync(appPath, 'placeholder');
-
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'reinstall',
-      positionals: ['com.example.app', appPath],
-      flags: {},
-    },
-    sessionName: 'default',
-    logPath: '/tmp/daemon.log',
-    sessionStore,
-    invoke,
-    reinstallOps: {
-      ios: async (_device, app, pathToBinary) => {
-        assert.equal(app, 'com.example.app');
-        assert.equal(pathToBinary, appPath);
-        return { bundleId: 'com.example.app' };
-      },
-      android: async () => {
-        throw new Error('unexpected android reinstall');
-      },
-    },
-  });
-
-  assert.ok(response);
-  assert.equal(response.ok, true);
-  if (response.ok) {
-    assert.equal(response.data?.platform, 'ios');
-    assert.equal(response.data?.appId, 'com.example.app');
-    assert.equal(response.data?.bundleId, 'com.example.app');
-    assert.equal(response.data?.appPath, appPath);
-  }
-  assert.equal(session.actions.length, 1);
-  assert.equal(session.actions[0]?.command, 'reinstall');
-});
-
-test('reinstall succeeds on active Android session with normalized appId', async () => {
-  const sessionStore = makeStore();
-  sessionStore.set(
-    'default',
-    makeSession('default', {
-      platform: 'android',
-      id: 'emulator-5554',
-      name: 'Pixel',
-      kind: 'emulator',
-      booted: true,
-    }),
-  );
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-reinstall-success-android-'));
-  const appPath = path.join(tempRoot, 'Sample.apk');
-  fs.writeFileSync(appPath, 'placeholder');
-
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'reinstall',
-      positionals: ['com.example.app', appPath],
-      flags: {},
-    },
-    sessionName: 'default',
-    logPath: '/tmp/daemon.log',
-    sessionStore,
-    invoke,
-    reinstallOps: {
-      ios: async () => {
-        throw new Error('unexpected ios reinstall');
-      },
-      android: async (_device, app, pathToBinary) => {
-        assert.equal(app, 'com.example.app');
-        assert.equal(pathToBinary, appPath);
-        return { package: 'com.example.app' };
-      },
-    },
-  });
-
-  assert.ok(response);
-  assert.equal(response.ok, true);
-  if (response.ok) {
-    assert.equal(response.data?.platform, 'android');
-    assert.equal(response.data?.appId, 'com.example.app');
-    assert.equal(response.data?.package, 'com.example.app');
-    assert.equal(response.data?.appPath, appPath);
-  }
-});

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

@@ -1,343 +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 { handleSessionCommands } from '../session.ts';
-import { SessionStore } from '../../session-store.ts';
-import type { DaemonRequest, DaemonResponse, SessionState } from '../../types.ts';
-
-function makeSessionStore(): SessionStore {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-session-handler-'));
-  return new SessionStore(path.join(root, 'sessions'));
-}
-
-function makeSession(name: string, device: SessionState['device']): SessionState {
-  return {
-    name,
-    device,
-    createdAt: Date.now(),
-    actions: [],
-  };
-}
-
-const noopInvoke = async (_req: DaemonRequest): Promise<DaemonResponse> => ({ ok: true, data: {} });
-
-test('boot requires session or explicit selector', async () => {
-  const sessionStore = makeSessionStore();
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'boot',
-      positionals: [],
-      flags: {},
-    },
-    sessionName: 'default',
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: noopInvoke,
-    ensureReady: async () => {},
-  });
-  assert.ok(response);
-  assert.equal(response?.ok, false);
-  if (response && !response.ok) {
-    assert.equal(response.error.code, 'INVALID_ARGS');
-  }
-});
-
-test('boot succeeds for iOS physical devices', async () => {
-  const sessionStore = makeSessionStore();
-  const sessionName = 'ios-device-session';
-  sessionStore.set(
-    sessionName,
-    makeSession(sessionName, {
-      platform: 'ios',
-      id: 'ios-device-1',
-      name: 'iPhone Device',
-      kind: 'device',
-      booted: true,
-    }),
-  );
-  let ensureCalls = 0;
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: sessionName,
-      command: 'boot',
-      positionals: [],
-      flags: {},
-    },
-    sessionName,
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: noopInvoke,
-    ensureReady: async () => {
-      ensureCalls += 1;
-    },
-  });
-  assert.ok(response);
-  assert.equal(response?.ok, true);
-  assert.equal(ensureCalls, 1);
-  if (response && response.ok) {
-    assert.equal(response.data?.platform, 'ios');
-    assert.equal(response.data?.booted, true);
-  }
-});
-
-test('boot succeeds for supported device in session', async () => {
-  const sessionStore = makeSessionStore();
-  const sessionName = 'android-session';
-  sessionStore.set(
-    sessionName,
-    makeSession(sessionName, {
-      platform: 'android',
-      id: 'emulator-5554',
-      name: 'Pixel Emulator',
-      kind: 'emulator',
-      booted: true,
-    }),
-  );
-  let ensureCalls = 0;
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: sessionName,
-      command: 'boot',
-      positionals: [],
-      flags: {},
-    },
-    sessionName,
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: noopInvoke,
-    ensureReady: async () => {
-      ensureCalls += 1;
-    },
-  });
-  assert.ok(response);
-  assert.equal(response?.ok, true);
-  assert.equal(ensureCalls, 1);
-  if (response && response.ok) {
-    assert.equal(response.data?.platform, 'android');
-    assert.equal(response.data?.booted, true);
-  }
-});
-
-test('open URL on existing iOS session clears stale app bundle id', async () => {
-  const sessionStore = makeSessionStore();
-  const sessionName = 'ios-session';
-  sessionStore.set(
-    sessionName,
-    {
-      ...makeSession(sessionName, {
-        platform: 'ios',
-        id: 'sim-1',
-        name: 'iPhone 15',
-        kind: 'simulator',
-        booted: true,
-      }),
-      appBundleId: 'com.example.old',
-      appName: 'Old App',
-    },
-  );
-
-  let dispatchedContext: Record<string, unknown> | undefined;
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: sessionName,
-      command: 'open',
-      positionals: ['https://example.com/path'],
-      flags: {},
-    },
-    sessionName,
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: noopInvoke,
-    dispatch: async (_device, _command, _positionals, _out, context) => {
-      dispatchedContext = context as Record<string, unknown> | undefined;
-      return {};
-    },
-    ensureReady: async () => {},
-  });
-
-  assert.ok(response);
-  assert.equal(response?.ok, true);
-  const updated = sessionStore.get(sessionName);
-  assert.equal(updated?.appBundleId, undefined);
-  assert.equal(updated?.appName, 'https://example.com/path');
-  assert.equal(dispatchedContext?.appBundleId, undefined);
-});
-
-test('open app on existing iOS session resolves and stores bundle id', async () => {
-  const sessionStore = makeSessionStore();
-  const sessionName = 'ios-session';
-  sessionStore.set(
-    sessionName,
-    {
-      ...makeSession(sessionName, {
-        platform: 'ios',
-        id: 'sim-1',
-        name: 'iPhone 15',
-        kind: 'simulator',
-        booted: true,
-      }),
-      appBundleId: 'com.example.old',
-      appName: 'Old App',
-    },
-  );
-
-  let dispatchedContext: Record<string, unknown> | undefined;
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: sessionName,
-      command: 'open',
-      positionals: ['settings'],
-      flags: {},
-    },
-    sessionName,
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: noopInvoke,
-    dispatch: async (_device, _command, _positionals, _out, context) => {
-      dispatchedContext = context as Record<string, unknown> | undefined;
-      return {};
-    },
-    ensureReady: async () => {},
-  });
-
-  assert.ok(response);
-  assert.equal(response?.ok, true);
-  const updated = sessionStore.get(sessionName);
-  assert.equal(updated?.appBundleId, 'com.apple.Preferences');
-  assert.equal(updated?.appName, 'settings');
-  assert.equal(dispatchedContext?.appBundleId, 'com.apple.Preferences');
-});
-
-test('open --relaunch closes and reopens active session app', async () => {
-  const sessionStore = makeSessionStore();
-  const sessionName = 'android-session';
-  sessionStore.set(
-    sessionName,
-    {
-      ...makeSession(sessionName, {
-        platform: 'android',
-        id: 'emulator-5554',
-        name: 'Pixel Emulator',
-        kind: 'emulator',
-        booted: true,
-      }),
-      appName: 'com.example.app',
-    },
-  );
-
-  const calls: Array<{ command: string; positionals: string[] }> = [];
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: sessionName,
-      command: 'open',
-      positionals: [],
-      flags: { relaunch: true },
-    },
-    sessionName,
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: noopInvoke,
-    dispatch: async (_device, command, positionals) => {
-      calls.push({ command, positionals });
-      return {};
-    },
-  });
-
-  assert.ok(response);
-  assert.equal(response?.ok, true);
-  assert.equal(calls.length, 2);
-  assert.deepEqual(calls[0], { command: 'close', positionals: ['com.example.app'] });
-  assert.deepEqual(calls[1], { command: 'open', positionals: ['com.example.app'] });
-});
-
-test('open --relaunch rejects URL targets', async () => {
-  const sessionStore = makeSessionStore();
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'open',
-      positionals: ['https://example.com/path'],
-      flags: { relaunch: true },
-    },
-    sessionName: 'default',
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: noopInvoke,
-  });
-
-  assert.ok(response);
-  assert.equal(response?.ok, false);
-  if (response && !response.ok) {
-    assert.equal(response.error.code, 'INVALID_ARGS');
-    assert.match(response.error.message, /does not support URL targets/i);
-  }
-});
-
-test('open --relaunch fails without app when no session exists', async () => {
-  const sessionStore = makeSessionStore();
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'open',
-      positionals: [],
-      flags: { relaunch: true },
-    },
-    sessionName: 'default',
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: noopInvoke,
-  });
-
-  assert.ok(response);
-  assert.equal(response?.ok, false);
-  if (response && !response.ok) {
-    assert.equal(response.error.code, 'INVALID_ARGS');
-    assert.match(response.error.message, /requires an app argument/i);
-  }
-});
-
-test('replay parses open --relaunch flag and replays open with relaunch semantics', async () => {
-  const sessionStore = makeSessionStore();
-  const replayRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-relaunch-'));
-  const replayPath = path.join(replayRoot, 'relaunch.ad');
-  fs.writeFileSync(replayPath, 'open "Settings" --relaunch\n');
-
-  const invoked: DaemonRequest[] = [];
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'replay',
-      positionals: [replayPath],
-      flags: {},
-    },
-    sessionName: 'default',
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: async (req) => {
-      invoked.push(req);
-      return { ok: true, data: {} };
-    },
-  });
-
-  assert.ok(response);
-  assert.equal(response?.ok, true);
-  if (response && response.ok) {
-    assert.equal(response.data?.replayed, 1);
-  }
-  assert.equal(invoked.length, 1);
-  assert.equal(invoked[0]?.command, 'open');
-  assert.deepEqual(invoked[0]?.positionals, ['Settings']);
-  assert.equal(invoked[0]?.flags?.relaunch, true);
-});

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);
-  }
-});