refactor: centralize lease scope projection

Author: thymikee

src/client-normalizers.ts

@@ -4,6 +4,11 @@ import type { DaemonRequest, SessionRuntimeHints } from './daemon/types.ts';
 import { AppError, type NormalizedError } from './utils/errors.ts';
 import type { SnapshotNode } from './utils/snapshot.ts';
 import { buildAppIdentifiers, buildDeviceIdentifiers } from './client-shared.ts';
+import {
+  leaseScopeFromOptions,
+  leaseScopeToCommandFlags,
+  leaseScopeToRequestMeta,
+} from './core/lease-scope.ts';
 import type {
   AgentDeviceDevice,
   AgentDeviceSession,
@@ -157,13 +162,12 @@ function buildClientDevicePlatformFields(
 }
 
 export function normalizeRuntimeHints(value: unknown): SessionRuntimeHints | undefined {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) return undefined;
-  const record = value as Record<string, unknown>;
-  const platform = record.platform;
-  const metroHost = readOptionalString(record, 'metroHost');
-  const metroPort = typeof record.metroPort === 'number' ? record.metroPort : undefined;
-  const bundleUrl = readOptionalString(record, 'bundleUrl');
-  const launchUrl = readOptionalString(record, 'launchUrl');
+  if (!isRecord(value)) return undefined;
+  const platform = value.platform;
+  const metroHost = readOptionalString(value, 'metroHost');
+  const metroPort = typeof value.metroPort === 'number' ? value.metroPort : undefined;
+  const bundleUrl = readOptionalString(value, 'bundleUrl');
+  const launchUrl = readOptionalString(value, 'launchUrl');
   return {
     platform: platform === 'ios' || platform === 'android' ? platform : undefined,
     metroHost,
@@ -211,21 +215,20 @@ export function normalizeOpenDevice(
 }
 
 export function normalizeStartupSample(value: unknown): StartupPerfSample | undefined {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) return undefined;
-  const record = value as Record<string, unknown>;
+  if (!isRecord(value)) return undefined;
   if (
-    typeof record.durationMs !== 'number' ||
-    typeof record.measuredAt !== 'string' ||
-    typeof record.method !== 'string'
+    typeof value.durationMs !== 'number' ||
+    typeof value.measuredAt !== 'string' ||
+    typeof value.method !== 'string'
   ) {
     return undefined;
   }
   return {
-    durationMs: record.durationMs,
-    measuredAt: record.measuredAt,
-    method: record.method,
-    appTarget: readOptionalString(record, 'appTarget'),
-    appBundleId: readOptionalString(record, 'appBundleId'),
+    durationMs: value.durationMs,
+    measuredAt: value.measuredAt,
+    method: value.method,
+    appTarget: readOptionalString(value, 'appTarget'),
+    appBundleId: readOptionalString(value, 'appBundleId'),
   };
 }
 
@@ -268,17 +271,15 @@ export function readSnapshotNodes(value: unknown): SnapshotNode[] {
 }
 
 export function buildFlags(options: InternalRequestOptions): CommandFlags {
+  const leaseScope = leaseScopeFromOptions(options);
   return stripUndefined({
     stateDir: options.stateDir,
     daemonBaseUrl: options.daemonBaseUrl,
     daemonAuthToken: options.daemonAuthToken,
     daemonTransport: options.daemonTransport,
     daemonServerMode: options.daemonServerMode,
-    tenant: options.tenant,
+    ...leaseScopeToCommandFlags(leaseScope),
     sessionIsolation: options.sessionIsolation,
-    runId: options.runId,
-    leaseId: options.leaseId,
-    leaseBackend: options.leaseBackend,
     platform: options.platform,
     target: options.target,
     device: options.device,
@@ -352,21 +353,15 @@ export function buildFlags(options: InternalRequestOptions): CommandFlags {
 }
 
 export function buildMeta(options: InternalRequestOptions): DaemonRequest['meta'] {
+  const leaseScope = leaseScopeFromOptions(options);
   return stripUndefined({
     requestId: options.requestId,
     cwd: options.cwd,
     sessionExplicit: options.session !== undefined,
     debug: options.debug,
     lockPolicy: options.lockPolicy,
     lockPlatform: options.lockPlatform,
-    tenantId: options.tenant,
-    runId: options.runId,
-    leaseId: options.leaseId,
-    leaseBackend: options.leaseBackend,
-    leaseTtlMs: options.leaseTtlMs,
-    leaseProvider: options.leaseProvider,
-    clientId: options.clientId,
-    deviceKey: options.deviceKey,
+    ...leaseScopeToRequestMeta(leaseScope),
     sessionIsolation: options.sessionIsolation,
     installSource: options.installSource,
     retainMaterializedPaths: options.retainMaterializedPaths,

src/client.ts

@@ -215,16 +215,10 @@ export function createAgentDeviceClient(
           await execute(INTERNAL_COMMANDS.leaseAllocate, [], {
             ...options,
             leaseId: undefined,
-            leaseTtlMs: options.ttlMs,
           }),
         ),
       heartbeat: async (options) =>
-        normalizeLease(
-          await execute(INTERNAL_COMMANDS.leaseHeartbeat, [], {
-            ...options,
-            leaseTtlMs: options.ttlMs,
-          }),
-        ),
+        normalizeLease(await execute(INTERNAL_COMMANDS.leaseHeartbeat, [], options)),
       release: async (options) => {
         const data = await execute(INTERNAL_COMMANDS.leaseRelease, [], options);
         return { released: data.released === true };

src/core/__tests__/lease-scope.test.ts

@@ -0,0 +1,167 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import {
+  findMissingProxyLeaseFields,
+  leaseScopeFromOptions,
+  leaseScopeFromRequest,
+  leaseScopeToCommandFlags,
+  leaseScopeToConnectionMetadata,
+  leaseScopeToLeaseRpcParams,
+  leaseScopeToRequestMeta,
+} from '../lease-scope.ts';
+
+test('leaseScopeFromOptions normalizes public aliases and projects request meta', () => {
+  const scope = leaseScopeFromOptions({
+    tenant: 'tenant-a',
+    runId: 'run-1',
+    leaseId: 'lease-1',
+    ttlMs: 120_000,
+    leaseBackend: 'ios-instance',
+    provider: 'proxy',
+    deviceKey: 'ios:SIM-001',
+    clientId: 'client-a',
+  });
+
+  assert.deepEqual(scope, {
+    tenantId: 'tenant-a',
+    runId: 'run-1',
+    leaseId: 'lease-1',
+    leaseTtlMs: 120_000,
+    leaseBackend: 'ios-instance',
+    leaseProvider: 'proxy',
+    deviceKey: 'ios:SIM-001',
+    clientId: 'client-a',
+  });
+  assert.deepEqual(leaseScopeToRequestMeta(scope), {
+    tenantId: 'tenant-a',
+    runId: 'run-1',
+    leaseId: 'lease-1',
+    leaseTtlMs: 120_000,
+    leaseBackend: 'ios-instance',
+    leaseProvider: 'proxy',
+    deviceKey: 'ios:SIM-001',
+    clientId: 'client-a',
+  });
+  assert.deepEqual(leaseScopeToCommandFlags(scope), {
+    tenant: 'tenant-a',
+    runId: 'run-1',
+    leaseId: 'lease-1',
+    leaseBackend: 'ios-instance',
+  });
+});
+
+test('leaseScopeFromRequest prefers metadata and falls back to legacy flags', () => {
+  assert.deepEqual(
+    leaseScopeFromRequest({
+      meta: {
+        tenantId: 'tenant-meta',
+        leaseProvider: 'limrun',
+      },
+      flags: {
+        tenant: 'tenant-flag',
+        runId: 'run-flag',
+        leaseId: 'lease-flag',
+        provider: 'proxy',
+        deviceKey: 'ios:SIM-001',
+        clientId: 'client-a',
+      },
+    }),
+    {
+      tenantId: 'tenant-meta',
+      runId: 'run-flag',
+      leaseId: 'lease-flag',
+      leaseProvider: 'limrun',
+      deviceKey: 'ios:SIM-001',
+      clientId: 'client-a',
+    },
+  );
+});
+
+test('leaseScopeToLeaseRpcParams preserves provider alias and command-specific fields', () => {
+  const scope = leaseScopeFromOptions({
+    tenant: 'tenant-a',
+    runId: 'run-1',
+    leaseId: 'lease-1',
+    leaseTtlMs: 60_000,
+    leaseBackend: 'android-instance',
+    leaseProvider: 'proxy',
+    deviceKey: 'android:emulator-5554',
+    clientId: 'client-a',
+  });
+
+  assert.deepEqual(
+    leaseScopeToLeaseRpcParams(scope, 'lease_allocate', {
+      includeTokenParam: true,
+      token: 'token',
+      session: 'default',
+    }),
+    {
+      token: 'token',
+      session: 'default',
+      tenantId: 'tenant-a',
+      runId: 'run-1',
+      leaseProvider: 'proxy',
+      provider: 'proxy',
+      clientId: 'client-a',
+      deviceKey: 'android:emulator-5554',
+      ttlMs: 60_000,
+      backend: 'android-instance',
+    },
+  );
+  assert.deepEqual(
+    leaseScopeToLeaseRpcParams(scope, 'lease_release', {
+      includeTokenParam: false,
+      token: 'token',
+      session: 'default',
+    }),
+    {
+      session: 'default',
+      tenantId: 'tenant-a',
+      runId: 'run-1',
+      leaseProvider: 'proxy',
+      provider: 'proxy',
+      clientId: 'client-a',
+      deviceKey: 'android:emulator-5554',
+      leaseId: 'lease-1',
+    },
+  );
+});
+
+test('leaseScopeToConnectionMetadata returns only connection lease fields', () => {
+  assert.deepEqual(
+    leaseScopeToConnectionMetadata(
+      leaseScopeFromOptions({
+        tenant: 'tenant-a',
+        runId: 'run-1',
+        leaseId: 'lease-1',
+        leaseProvider: 'proxy',
+        deviceKey: 'ios:SIM-001',
+        clientId: 'client-a',
+      }),
+    ),
+    {
+      leaseProvider: 'proxy',
+      deviceKey: 'ios:SIM-001',
+      clientId: 'client-a',
+    },
+  );
+  assert.equal(leaseScopeToConnectionMetadata({}), undefined);
+});
+
+test('findMissingProxyLeaseFields enforces complete proxy ownership scope', () => {
+  assert.deepEqual(
+    findMissingProxyLeaseFields({
+      tenantId: 'tenant-a',
+      runId: 'run-1',
+      leaseProvider: 'proxy',
+      clientId: 'client-a',
+    }),
+    ['leaseId', 'deviceKey'],
+  );
+  assert.deepEqual(
+    findMissingProxyLeaseFields({
+      leaseProvider: 'limrun',
+    }),
+    [],
+  );
+});