refactor: extract request execution scope (#523)

Author: thymikee

src/daemon/__tests__/request-execution-scope.test.ts

@@ -0,0 +1,187 @@
+import { test, expect } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { withDiagnosticsScope } from '../../utils/diagnostics.ts';
+import {
+  makeAndroidSession,
+  makeIosSession,
+} from '../../__tests__/test-utils/session-factories.ts';
+import { makeSessionStore } from '../../__tests__/test-utils/store-factory.ts';
+import { LeaseRegistry } from '../lease-registry.ts';
+import { clearRequestCanceled, markRequestCanceled } from '../request-cancel.ts';
+import {
+  createRequestExecutionScope,
+  prepareLockedRequestScope,
+} from '../request-execution-scope.ts';
+import type { DaemonRequest } from '../types.ts';
+
+const TEST_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-request-execution-scope-'));
+const LOG_PATH = path.join(TEST_ROOT, 'diagnostics.log');
+
+test('createRequestExecutionScope applies tenant scoping and lease admission', async () => {
+  const sessionStore = makeSessionStore('agent-device-request-scope-');
+  const leaseRegistry = new LeaseRegistry();
+  const lease = leaseRegistry.allocateLease({ tenantId: 'tenant-a', runId: 'run-1' });
+
+  const scope = await createRequestExecutionScope({
+    req: makeRequest({
+      session: 'default',
+      command: 'snapshot',
+      meta: {
+        tenantId: 'tenant-a',
+        runId: 'run-1',
+        leaseId: lease.leaseId,
+        sessionIsolation: 'tenant',
+      },
+    }),
+    sessionStore,
+    leaseRegistry,
+  });
+
+  expect(scope.req.session).toBe('tenant-a:default');
+  expect(scope.req.meta?.tenantId).toBe('tenant-a');
+  expect(scope.sessionName).toBe('tenant-a:default');
+});
+
+test('createRequestExecutionScope rejects tenant requests without an active lease', async () => {
+  await expect(
+    createRequestExecutionScope({
+      req: makeRequest({
+        session: 'default',
+        command: 'snapshot',
+        meta: {
+          tenantId: 'tenant-a',
+          runId: 'run-1',
+          leaseId: '0'.repeat(32),
+          sessionIsolation: 'tenant',
+        },
+      }),
+      sessionStore: makeSessionStore('agent-device-request-scope-'),
+      leaseRegistry: new LeaseRegistry(),
+    }),
+  ).rejects.toThrow(/Lease is not active/);
+});
+
+test('prepareLockedRequestScope preserves existing-session selector validation', async () => {
+  const sessionStore = makeSessionStore('agent-device-request-scope-');
+  sessionStore.set('default', makeAndroidSession('default'));
+  const scope = await createRequestExecutionScope({
+    req: makeRequest({
+      command: 'snapshot',
+      flags: {
+        platform: 'ios',
+      },
+    }),
+    sessionStore,
+    leaseRegistry: new LeaseRegistry(),
+  });
+
+  expect(() =>
+    prepareLockedRequestScope({
+      scope,
+      logPath: LOG_PATH,
+      sessionStore,
+      trackDownloadableArtifact: () => 'artifact-id',
+    }),
+  ).toThrow(/cannot be used with --platform=ios/i);
+});
+
+test('prepareLockedRequestScope blocks commands for invalidated recordings before handlers run', async () => {
+  const sessionStore = makeSessionStore('agent-device-request-scope-');
+  sessionStore.set(
+    'default',
+    makeIosSession('default', {
+      recording: {
+        platform: 'ios-device-runner',
+        outPath: '/tmp/recording.mp4',
+        remotePath: '/tmp/remote.mp4',
+        startedAt: Date.now(),
+        showTouches: true,
+        gestureEvents: [],
+        invalidatedReason: 'iOS runner session restarted during recording',
+      },
+    }),
+  );
+  const scope = await createRequestExecutionScope({
+    req: makeRequest({ command: 'snapshot' }),
+    sessionStore,
+    leaseRegistry: new LeaseRegistry(),
+  });
+
+  const result = await withDiagnosticsScope({ command: 'snapshot', logPath: LOG_PATH }, async () =>
+    prepareLockedRequestScope({
+      scope,
+      logPath: LOG_PATH,
+      sessionStore,
+      trackDownloadableArtifact: () => 'artifact-id',
+    }),
+  );
+
+  expect(result.type).toBe('response');
+  if (result.type === 'response') {
+    expect(result.response.ok).toBe(false);
+    if (!result.response.ok) {
+      expect(result.response.error.message).toBe('iOS runner session restarted during recording');
+    }
+  }
+});
+
+test('runLocked rejects a canceled request before executing work', async () => {
+  const requestId = 'request-scope-canceled-before-lock';
+  const scope = await createRequestExecutionScope({
+    req: makeRequest({ meta: { requestId } }),
+    sessionStore: makeSessionStore('agent-device-request-scope-'),
+    leaseRegistry: new LeaseRegistry(),
+  });
+
+  markRequestCanceled(requestId);
+  try {
+    await expect(scope.runLocked(async () => 'ran')).rejects.toThrow(/request canceled/);
+  } finally {
+    clearRequestCanceled(requestId);
+  }
+});
+
+test('runLocked rejects a request canceled while waiting for its execution lock', async () => {
+  const requestId = 'request-scope-canceled-after-lock';
+  const sessionStore = makeSessionStore('agent-device-request-scope-');
+  sessionStore.set('default', makeIosSession('default'));
+  const leaseRegistry = new LeaseRegistry();
+  const first = await createRequestExecutionScope({
+    req: makeRequest({ command: 'click' }),
+    sessionStore,
+    leaseRegistry,
+  });
+  const second = await createRequestExecutionScope({
+    req: makeRequest({ command: 'click', meta: { requestId } }),
+    sessionStore,
+    leaseRegistry,
+  });
+  let releaseLock: () => void = () => {};
+  const lockReleased = new Promise<void>((resolve) => {
+    releaseLock = resolve;
+  });
+  const firstRun = first.runLocked(async () => await lockReleased);
+  const secondRun = second.runLocked(async () => 'ran');
+  const secondExpectation = expect(secondRun).rejects.toThrow(/request canceled/);
+
+  markRequestCanceled(requestId);
+  releaseLock();
+  try {
+    await firstRun;
+    await secondExpectation;
+  } finally {
+    clearRequestCanceled(requestId);
+  }
+});
+
+function makeRequest(overrides: Partial<DaemonRequest> = {}): DaemonRequest {
+  return {
+    token: 'test-token',
+    session: 'default',
+    command: 'snapshot',
+    positionals: [],
+    ...overrides,
+  };
+}

src/daemon/request-android-adb.ts

@@ -1,6 +1,7 @@
 import {
   type AndroidAdbExecutor,
   type AndroidAdbProvider,
+  withAndroidAdbProvider,
 } from '../platforms/android/adb-executor.ts';
 import { resolveTargetDevice } from '../core/dispatch-resolve.ts';
 import type { DeviceInfo } from '../utils/device.ts';
@@ -18,7 +19,7 @@ export type AndroidAdbProviderResolver = (params: {
   session?: AndroidAdbProviderRequestSession;
 }) => AndroidAdbProvider | AndroidAdbExecutor | undefined;
 
-export async function resolveScopedAndroidAdbProvider(params: {
+async function resolveScopedAndroidAdbProvider(params: {
   req: DaemonRequest;
   existingSession: SessionState | undefined;
   androidAdbProvider?: AndroidAdbProviderResolver;
@@ -36,6 +37,26 @@ export async function resolveScopedAndroidAdbProvider(params: {
   return { provider, executor, serial: device.id };
 }
 
+export async function withRequestAndroidAdbScope<T>(
+  params: {
+    req: DaemonRequest;
+    existingSession: SessionState | undefined;
+    androidAdbProvider?: AndroidAdbProviderResolver;
+  },
+  task: (adb: { executor?: AndroidAdbExecutor }) => Promise<T>,
+): Promise<T> {
+  const requestAdb = await resolveScopedAndroidAdbProvider({
+    req: params.req,
+    existingSession: params.existingSession,
+    androidAdbProvider: params.androidAdbProvider,
+  });
+  return await withAndroidAdbProvider(
+    requestAdb.provider,
+    { serial: requestAdb.serial ?? '' },
+    async () => await task({ executor: requestAdb.executor }),
+  );
+}
+
 async function resolveAndroidAdbProviderDevice(
   req: DaemonRequest,
   existingSession: SessionState | undefined,

src/daemon/request-cancel.ts

@@ -87,6 +87,12 @@ export function createRequestCanceledError(): AppError {
   });
 }
 
+export function throwIfRequestCanceled(requestId: string | undefined): void {
+  if (isRequestCanceled(requestId)) {
+    throw createRequestCanceledError();
+  }
+}
+
 export function isRequestCanceledError(error: unknown): boolean {
   if (!(error instanceof AppError)) return false;
   if (error.code !== 'COMMAND_FAILED') return false;