request-platform-providers.ts

import { resolveTargetDevice } from '../core/dispatch-resolve.ts';
import {
  type AndroidAdbExecutor,
  type AndroidAdbProvider,
  withAndroidAdbProvider,
} from '../platforms/android/adb-executor.ts';
import {
  type AppleRunnerCommandExecutor,
  type AppleRunnerProvider,
  withAppleRunnerProvider,
} from '../platforms/ios/runner-provider.ts';
import {
  type AppleToolCommandExecutor,
  type AppleToolProvider,
  withAppleToolProvider,
} from '../platforms/ios/tool-provider.ts';
import { type LinuxToolProvider, withLinuxToolProvider } from '../platforms/linux/tool-provider.ts';
import { isApplePlatform, type DeviceInfo } from '../utils/device.ts';
import { type AppLogProvider, withAppLogProvider } from './app-log.ts';
import { hasExplicitDeviceSelector } from './handlers/session-device-utils.ts';
import { type RecordingProvider, withRecordingProvider } from './recording-provider.ts';
import type { DaemonRequest, SessionState } from './types.ts';
import { PUBLIC_COMMANDS } from '../command-catalog.ts';

export type PlatformProviderRequestSession = Pick<
  SessionState,
  'name' | 'device' | 'appBundleId' | 'appName' | 'surface'
>;

export type AndroidAdbProviderResolver = (params: {
  req: DaemonRequest;
  device: DeviceInfo;
  session?: PlatformProviderRequestSession;
}) => AndroidAdbProvider | AndroidAdbExecutor | undefined;

export type AppleRunnerProviderResolver = (params: {
  req: DaemonRequest;
  device: DeviceInfo;
  session?: PlatformProviderRequestSession;
}) => AppleRunnerProvider | AppleRunnerCommandExecutor | undefined;

export type AppleToolProviderResolver = (params: {
  req: DaemonRequest;
  device: DeviceInfo;
  session?: PlatformProviderRequestSession;
}) => AppleToolProvider | AppleToolCommandExecutor | undefined;

export type LinuxToolProviderResolver = (params: {
  req: DaemonRequest;
  device: DeviceInfo;
  session?: PlatformProviderRequestSession;
}) => LinuxToolProvider | undefined;

export type AppLogProviderResolver = (params: {
  req: DaemonRequest;
  device: DeviceInfo;
  session?: PlatformProviderRequestSession;
}) => AppLogProvider | undefined;

export type RecordingProviderResolver = (params: {
  req: DaemonRequest;
  device: DeviceInfo;
  session?: PlatformProviderRequestSession;
}) => RecordingProvider | undefined;

export type PlatformProviderResolvers = {
  androidAdbProvider?: AndroidAdbProviderResolver;
  appleRunnerProvider?: AppleRunnerProviderResolver;
  appleToolProvider?: AppleToolProviderResolver;
  linuxToolProvider?: LinuxToolProviderResolver;
  appLogProvider?: AppLogProviderResolver;
  recordingProvider?: RecordingProviderResolver;
};

export type RequestPlatformProviderScope = {
  androidAdbExecutor?: AndroidAdbExecutor;
};

type RequestPlatformProviderParams = {
  req: DaemonRequest;
  existingSession: SessionState | undefined;
  providers: PlatformProviderResolvers;
};

type RequestPlatformProviderResolverContext = {
  req: DaemonRequest;
  device: DeviceInfo;
  session?: PlatformProviderRequestSession;
};

type ResolvedRequestPlatformProviders = {
  androidAdb?: {
    provider?: AndroidAdbProvider | AndroidAdbExecutor;
    executor?: AndroidAdbExecutor;
    serial?: string;
  };
  appleRunner?: {
    provider?: AppleRunnerProvider | AppleRunnerCommandExecutor;
    deviceId?: string;
    requestId?: string;
  };
  appleTool?: {
    provider?: AppleToolProvider | AppleToolCommandExecutor;
  };
  linuxTool?: {
    provider?: LinuxToolProvider;
  };
  appLog?: {
    provider?: AppLogProvider;
  };
  recording?: {
    provider?: RecordingProvider;
  };
};

type RequestPlatformProviderScopeWrapper = <T>(task: () => Promise<T>) => Promise<T>;

type RequestPlatformProviderDescriptor = {
  resolverKey: keyof PlatformProviderResolvers;
  resolve: (
    providers: PlatformProviderResolvers,
    context: RequestPlatformProviderResolverContext,
  ) => ResolvedRequestPlatformProviders;
  appendWrapper: (
    scopedProviders: ResolvedRequestPlatformProviders,
    wrappers: RequestPlatformProviderScopeWrapper[],
  ) => void;
};

const REQUEST_PLATFORM_PROVIDER_DESCRIPTORS = [
  {
    resolverKey: 'androidAdbProvider',
    resolve(providers, context) {
      const androidAdbProvider = providers.androidAdbProvider;
      if (!androidAdbProvider || context.device.platform !== 'android') return {};
      const provider = androidAdbProvider(context);
      const executor = typeof provider === 'function' ? provider : provider?.exec;
      return { androidAdb: { provider, executor, serial: context.device.id } };
    },
    appendWrapper(scopedProviders, wrappers) {
      appendRequestProviderWrapper(wrappers, scopedProviders.androidAdb, (provider, task) =>
        withAndroidAdbProvider(
          provider,
          { serial: scopedProviders.androidAdb?.serial ?? '' },
          task,
        ),
      );
    },
  },
  {
    resolverKey: 'appleRunnerProvider',
    resolve(providers, context) {
      const appleRunnerProvider = providers.appleRunnerProvider;
      if (!appleRunnerProvider || !isApplePlatform(context.device.platform)) return {};
      const provider = appleRunnerProvider(context);
      return {
        appleRunner: {
          provider,
          deviceId: context.device.id,
          requestId: context.req.meta?.requestId,
        },
      };
    },
    appendWrapper(scopedProviders, wrappers) {
      appendRequestProviderWrapper(wrappers, scopedProviders.appleRunner, (provider, task) =>
        withAppleRunnerProvider(
          provider,
          {
            deviceId: scopedProviders.appleRunner?.deviceId ?? '',
            requestId: scopedProviders.appleRunner?.requestId,
          },
          task,
        ),
      );
    },
  },
  {
    resolverKey: 'appleToolProvider',
    resolve(providers, context) {
      const appleToolProvider = providers.appleToolProvider;
      if (!appleToolProvider || !isApplePlatform(context.device.platform)) return {};
      return { appleTool: { provider: appleToolProvider(context) } };
    },
    appendWrapper(scopedProviders, wrappers) {
      appendRequestProviderWrapper(wrappers, scopedProviders.appleTool, withAppleToolProvider);
    },
  },
  {
    resolverKey: 'linuxToolProvider',
    resolve(providers, context) {
      const linuxToolProvider = providers.linuxToolProvider;
      if (!linuxToolProvider || context.device.platform !== 'linux') return {};
      return { linuxTool: { provider: linuxToolProvider(context) } };
    },
    appendWrapper(scopedProviders, wrappers) {
      appendRequestProviderWrapper(wrappers, scopedProviders.linuxTool, withLinuxToolProvider);
    },
  },
  {
    resolverKey: 'appLogProvider',
    resolve(providers, context) {
      const appLogProvider = providers.appLogProvider;
      if (!appLogProvider) return {};
      return { appLog: { provider: appLogProvider(context) } };
    },
    appendWrapper(scopedProviders, wrappers) {
      appendRequestProviderWrapper(wrappers, scopedProviders.appLog, withAppLogProvider);
    },
  },
  {
    resolverKey: 'recordingProvider',
    resolve(providers, context) {
      const recordingProvider = providers.recordingProvider;
      if (!recordingProvider) return {};
      return { recording: { provider: recordingProvider(context) } };
    },
    appendWrapper(scopedProviders, wrappers) {
      appendRequestProviderWrapper(wrappers, scopedProviders.recording, withRecordingProvider);
    },
  },
] satisfies RequestPlatformProviderDescriptor[];

export async function withRequestPlatformProviderScope<T>(
  params: RequestPlatformProviderParams,
  task: (scope: RequestPlatformProviderScope) => Promise<T>,
): Promise<T> {
  const scopedProviders = await resolveRequestPlatformProviders(params);
  const scope: RequestPlatformProviderScope = {
    androidAdbExecutor: scopedProviders.androidAdb?.executor,
  };
  const wrappers = requestPlatformProviderScopeWrappers(scopedProviders);

  return await runRequestPlatformProviderScopes(wrappers, async () => await task(scope));
}

async function resolveRequestPlatformProviders(
  params: RequestPlatformProviderParams,
): Promise<ResolvedRequestPlatformProviders> {
  if (!hasPlatformProviderResolvers(params.providers)) return {};
  const device = await resolveScopedProviderDevice(params.req, params.existingSession);
  if (!device) return {};
  const context = requestProviderResolverContext(params, device);
  return REQUEST_PLATFORM_PROVIDER_DESCRIPTORS.reduce<ResolvedRequestPlatformProviders>(
    (resolved, descriptor) => ({
      ...resolved,
      ...descriptor.resolve(params.providers, context),
    }),
    {},
  );
}

function hasPlatformProviderResolvers(providers: PlatformProviderResolvers): boolean {
  return REQUEST_PLATFORM_PROVIDER_DESCRIPTORS.some((descriptor) =>
    Boolean(providers[descriptor.resolverKey]),
  );
}

function requestProviderResolverContext(
  params: RequestPlatformProviderParams,
  device: DeviceInfo,
): RequestPlatformProviderResolverContext {
  return {
    req: params.req,
    device,
    session: params.existingSession,
  };
}

async function resolveScopedProviderDevice(
  req: DaemonRequest,
  existingSession: SessionState | undefined,
): Promise<DeviceInfo | undefined> {
  if (existingSession) {
    return req.command === PUBLIC_COMMANDS.apps && hasExplicitDeviceSelector(req.flags)
      ? await resolveTargetDevice(req.flags ?? {})
      : existingSession.device;
  }
  if (
    req.command !== PUBLIC_COMMANDS.open &&
    !hasExplicitDeviceSelector(req.flags) &&
    !usesSessionlessDefaultDevice(req)
  ) {
    return undefined;
  }
  return await resolveTargetDevice(req.flags ?? {});
}

function usesSessionlessDefaultDevice(req: DaemonRequest): boolean {
  return (
    req.command === PUBLIC_COMMANDS.record && (req.positionals?.[0] ?? '').toLowerCase() === 'start'
  );
}

function requestPlatformProviderScopeWrappers(
  scopedProviders: ResolvedRequestPlatformProviders,
): RequestPlatformProviderScopeWrapper[] {
  const wrappers: RequestPlatformProviderScopeWrapper[] = [];
  for (const descriptor of REQUEST_PLATFORM_PROVIDER_DESCRIPTORS) {
    descriptor.appendWrapper(scopedProviders, wrappers);
  }
  return wrappers;
}

function appendRequestProviderWrapper<TProvider>(
  wrappers: RequestPlatformProviderScopeWrapper[],
  resolved: { provider?: TProvider } | undefined,
  withProvider: <T>(provider: TProvider, task: () => Promise<T>) => Promise<T>,
): void {
  const provider = resolved?.provider;
  if (!provider) return;
  wrappers.push(async (task) => await withProvider(provider, task));
}

async function runRequestPlatformProviderScopes<T>(
  wrappers: RequestPlatformProviderScopeWrapper[],
  task: () => Promise<T>,
): Promise<T> {
  let run = task;
  for (const wrapper of [...wrappers].reverse()) {
    const next = run;
    run = async () => await wrapper(next);
  }
  return await run();
}