@react-native-harness/cli 1.0.0-alpha.15 → 1.0.0-alpha.18

package/src/platforms/ios/simulator.ts

@@ -1,171 +0,0 @@
-import { spawn, SubprocessError } from '@react-native-harness/tools';
-
-export type IOSSimulatorStatus = 'stopped' | 'loading' | 'running';
-
-export const getSimulatorDeviceId = async (
-  simulatorName: string,
-  systemVersion: string
-): Promise<string | null> => {
-  try {
-    const { stdout } = await spawn('xcrun', [
-      'simctl',
-      'list',
-      'devices',
-      '--json',
-    ]);
-    const devices = JSON.parse(stdout);
-    const expectedRuntimeId = `com.apple.CoreSimulator.SimRuntime.iOS-${systemVersion.replace(
-      /\./,
-      '-'
-    )}`;
-
-    const runtime = devices.devices[expectedRuntimeId];
-
-    if (!runtime) {
-      return null;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const device = runtime.find((d: any) => d.name === simulatorName);
-
-    if (device) {
-      return device.udid;
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-};
-
-export const getAvailableSimulators = async (): Promise<
-  Array<{ name: string; udid: string; runtime: string }>
-> => {
-  try {
-    const { stdout } = await spawn('xcrun', [
-      'simctl',
-      'list',
-      'devices',
-      '--json',
-    ]);
-    const devices = JSON.parse(stdout);
-    const simulators: Array<{
-      name: string;
-      udid: string;
-      runtime: string;
-    }> = [];
-
-    for (const runtime in devices.devices) {
-      if (runtime.includes('iOS')) {
-        const runtimeDevices = devices.devices[runtime];
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        runtimeDevices.forEach((device: any) => {
-          if (device.isAvailable) {
-            simulators.push({
-              name: device.name,
-              udid: device.udid,
-              runtime: runtime,
-            });
-          }
-        });
-      }
-    }
-
-    return simulators;
-  } catch {
-    return [];
-  }
-};
-
-export const getSimulatorStatus = async (
-  udid: string
-): Promise<IOSSimulatorStatus> => {
-  try {
-    const { stdout } = await spawn('xcrun', [
-      'simctl',
-      'list',
-      'devices',
-      '--json',
-    ]);
-    const devices = JSON.parse(stdout);
-
-    for (const runtime in devices.devices) {
-      if (runtime.includes('iOS')) {
-        const runtimeDevices = devices.devices[runtime];
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const device = runtimeDevices.find((d: any) => d.udid === udid);
-
-        if (device) {
-          switch (device.state) {
-            case 'Booted':
-              return 'running';
-            case 'Booting':
-              return 'loading';
-            default:
-              return 'stopped';
-          }
-        }
-      }
-    }
-
-    return 'stopped';
-  } catch {
-    return 'stopped';
-  }
-};
-
-export const runSimulator = async (udid: string): Promise<void> => {
-  try {
-    await spawn('xcrun', ['simctl', 'boot', udid]);
-  } catch (bootError) {
-    // Ignore if simulator is already booted
-    if (
-      bootError instanceof SubprocessError &&
-      !bootError.stderr?.includes(
-        'Unable to boot device in current state: Booted'
-      )
-    ) {
-      throw bootError;
-    }
-  }
-
-  await spawn('open', ['-a', 'Simulator']);
-
-  let attempts = 0;
-
-  while (true) {
-    attempts++;
-
-    const status = await getSimulatorStatus(udid);
-
-    if (status === 'running') {
-      break;
-    }
-
-    if (attempts > 10) {
-      throw new Error('Simulator not running');
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-  }
-};
-
-export const stopSimulator = async (udid: string): Promise<void> => {
-  await stopSimulatorById(udid);
-};
-
-const stopSimulatorById = async (udid: string): Promise<void> => {
-  try {
-    await spawn('xcrun', ['simctl', 'shutdown', udid]);
-  } catch (shutdownError) {
-    // Ignore if simulator is already shut down
-    if (
-      shutdownError instanceof SubprocessError &&
-      !shutdownError.stderr?.includes(
-        'Unable to shutdown device in current state: Shutdown'
-      )
-    ) {
-      throw shutdownError;
-    }
-  }
-};

package/src/platforms/platform-adapter.ts

@@ -1,11 +0,0 @@
-import { TestRunnerConfig } from '@react-native-harness/config';
-
-export type Environment = {
-  restart: () => Promise<void>;
-  dispose: () => Promise<void>;
-};
-
-export type PlatformAdapter = {
-  name: string;
-  getEnvironment: (runner: TestRunnerConfig) => Promise<Environment>;
-};

package/src/platforms/platform-registry.ts

@@ -1,26 +0,0 @@
-import { PlatformAdapter } from './platform-adapter.js';
-import androidPlatformAdapter from './android/index.js';
-import iosPlatformAdapter from './ios/index.js';
-import webPlatformAdapter from './web/index.js';
-import vegaPlatformAdapter from './vega/index.js';
-
-const platformAdapters = {
-  android: androidPlatformAdapter,
-  ios: iosPlatformAdapter,
-  web: webPlatformAdapter,
-  vega: vegaPlatformAdapter,
-};
-
-export const getPlatformAdapter = async (
-  platformName: string
-): Promise<PlatformAdapter> => {
-  if (!(platformName in platformAdapters)) {
-    throw new Error(`Platform adapter for ${platformName} not found`);
-  }
-
-  try {
-    return platformAdapters[platformName as keyof typeof platformAdapters];
-  } catch {
-    throw new Error(`Platform adapter for ${platformName} not found`);
-  }
-};

package/src/platforms/vega/build.ts

@@ -1,85 +0,0 @@
-import path from 'node:path';
-import { spawn } from '@react-native-harness/tools';
-
-export type VegaBuildTarget = 'sim_tv_x86_64' | 'sim_tv_aarch64';
-export type VegaBuildType = 'Debug' | 'Release';
-
-/**
- * Build Vega app and produce .vpkg file
- */
-export const buildVegaApp = async (
-  buildType: VegaBuildType = 'Release',
-  target?: VegaBuildTarget
-): Promise<void> => {
-  const args = ['run', 'build:app'];
-
-  if (buildType) {
-    args.push('-b', buildType);
-  }
-
-  if (target) {
-    args.push('-t', target);
-  }
-
-  await spawn('npm', args);
-};
-
-/**
- * Clean build artifacts
- */
-export const cleanBuild = async (): Promise<void> => {
-  await spawn('kepler', ['clean']);
-};
-
-/**
- * Get the expected .vpkg file path based on build configuration
- */
-export const getVpkgPath = (
-  appName: string,
-  buildType: VegaBuildType = 'Release',
-  target: VegaBuildTarget = 'sim_tv_x86_64'
-): string => {
-  const buildTypeStr = buildType.toLowerCase();
-  const vpkgFileName = `${appName}_${target}.vpkg`;
-
-  return path.join(
-    process.cwd(),
-    'build',
-    `${target}-${buildTypeStr}`,
-    vpkgFileName
-  );
-};
-
-/**
- * Launch an already installed app on specified Vega virtual device
- */
-export const runApp = async (
-  deviceId: string,
-  bundleId: string
-): Promise<void> => {
-  await spawn('kepler', [
-    'device',
-    'launch-app',
-    '--device',
-    deviceId,
-    '--appName',
-    bundleId,
-  ]);
-};
-
-/**
- * Kill/terminate app on specified Vega virtual device
- */
-export const killApp = async (
-  deviceId: string,
-  bundleId: string
-): Promise<void> => {
-  await spawn('kepler', [
-    'device',
-    'terminate-app',
-    '--device',
-    deviceId,
-    '--appName',
-    bundleId,
-  ]);
-};

package/src/platforms/vega/device.ts

@@ -1,258 +0,0 @@
-import { spawn } from '@react-native-harness/tools';
-
-export type VegaVirtualDeviceStatus = 'running' | 'stopped';
-
-/**
- * List all available Vega virtual devices
- * Returns array of device identifiers that can be used with kepler commands
- */
-export const listVegaDevices = async (): Promise<string[]> => {
-  try {
-    const { stdout } = await spawn('kepler', ['device', 'list']);
-    const lines = stdout.trim().split('\n');
-    const devices: string[] = [];
-
-    for (const line of lines) {
-      if (line.trim()) {
-        // Parse device line format: "VirtualDevice : tv - x86_64 - OS - hostname"
-        // or potentially "VegaTV_1 : tv - x86_64 - OS - hostname" for named instances
-        const deviceId = line.split(' : ')[0].trim();
-        if (
-          deviceId &&
-          (deviceId === 'VirtualDevice' || deviceId.startsWith('Vega'))
-        ) {
-          devices.push(deviceId);
-        }
-      }
-    }
-
-    return devices;
-  } catch {
-    return [];
-  }
-};
-
-/**
- * Check if a specific Vega virtual device is connected/available
- */
-export const isVegaDeviceConnected = async (
-  deviceId: string
-): Promise<boolean> => {
-  try {
-    const { stdout } = await spawn('kepler', [
-      'device',
-      'is-connected',
-      '--device',
-      deviceId,
-    ]);
-    return stdout.includes('is connected');
-  } catch {
-    return false;
-  }
-};
-
-/**
- * Check if an app is installed on the specified Vega virtual device
- */
-export const isAppInstalled = async (
-  deviceId: string,
-  bundleId: string
-): Promise<boolean> => {
-  try {
-    await spawn('kepler', [
-      'device',
-      'is-app-installed',
-      '--device',
-      deviceId,
-      '--appName',
-      bundleId,
-    ]);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-/**
- * Check if an app is currently running on the specified Vega virtual device
- */
-export const isAppRunning = async (
-  deviceId: string,
-  bundleId: string
-): Promise<boolean> => {
-  try {
-    await spawn('kepler', [
-      'device',
-      'is-app-running',
-      '--device',
-      deviceId,
-      '--appName',
-      bundleId,
-    ]);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-/**
- * Install app on specified Vega virtual device using .vpkg file
- */
-export const installApp = async (
-  deviceId: string,
-  vpkgPath: string
-): Promise<void> => {
-  await spawn('kepler', [
-    'device',
-    'install-app',
-    '-p',
-    vpkgPath,
-    '--device',
-    deviceId,
-  ]);
-};
-
-/**
- * Terminate app on specified Vega virtual device
- */
-export const terminateApp = async (
-  deviceId: string,
-  bundleId: string
-): Promise<void> => {
-  await spawn('kepler', [
-    'device',
-    'terminate-app',
-    '--device',
-    deviceId,
-    '--appName',
-    bundleId,
-  ]);
-};
-
-/**
- * Uninstall app from specified Vega virtual device
- */
-export const uninstallApp = async (
-  deviceId: string,
-  bundleId: string
-): Promise<void> => {
-  await spawn('kepler', [
-    'device',
-    'uninstall-app',
-    '--device',
-    deviceId,
-    '--appName',
-    bundleId,
-  ]);
-};
-
-/**
- * Start port forwarding for debugging on specified Vega virtual device
- */
-export const startPortForwarding = async (
-  deviceId: string,
-  port: number,
-  forward = true
-): Promise<void> => {
-  await spawn('kepler', [
-    'device',
-    'start-port-forwarding',
-    '--device',
-    deviceId,
-    '--port',
-    port.toString(),
-    '--forward',
-    forward.toString(),
-  ]);
-};
-
-/**
- * Stop port forwarding on specified Vega virtual device
- */
-export const stopPortForwarding = async (
-  deviceId: string,
-  port: number,
-  forward = true
-): Promise<void> => {
-  await spawn('kepler', [
-    'device',
-    'stop-port-forwarding',
-    '--device',
-    deviceId,
-    '--port',
-    port.toString(),
-    '--forward',
-    forward.toString(),
-  ]);
-};
-
-/**
- * Get status of a specific Vega virtual device
- * Note: Vega CLI might manage virtual devices globally, so this checks if the device is available
- */
-export const getVegaDeviceStatus = async (
-  deviceId: string
-): Promise<VegaVirtualDeviceStatus> => {
-  try {
-    // First check if the device is connected/available
-    const isConnected = await isVegaDeviceConnected(deviceId);
-    if (isConnected) {
-      return 'running';
-    }
-
-    // Check general virtual device status
-    const { stdout } = await spawn('kepler', ['virtual-device', 'status']);
-    // Parse the status output to determine if VVD is running
-    return stdout.toLowerCase().includes('running') ||
-      stdout.toLowerCase().includes('ready')
-      ? 'running'
-      : 'stopped';
-  } catch {
-    return 'stopped';
-  }
-};
-
-/**
- * Start Vega Virtual Device
- * Note: Vega might manage virtual devices globally, this starts the virtual device system
- */
-export const startVirtualDevice = async (): Promise<void> => {
-  await spawn('kepler', ['virtual-device', 'start']);
-
-  // Poll for VVD status until it's running
-  let attempts = 0;
-  const maxAttempts = 30; // 30 seconds timeout
-
-  while (attempts < maxAttempts) {
-    const { stdout } = await spawn('kepler', ['virtual-device', 'status']);
-    if (
-      stdout.toLowerCase().includes('running') ||
-      stdout.toLowerCase().includes('ready')
-    ) {
-      return;
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    attempts++;
-  }
-
-  throw new Error('Vega Virtual Device failed to start within timeout');
-};
-
-/**
- * Stop Vega Virtual Device
- */
-export const stopVirtualDevice = async (): Promise<void> => {
-  await spawn('kepler', ['virtual-device', 'stop']);
-};
-
-/**
- * Combined install and run command for specified Vega virtual device (Vega-specific convenience method)
- */
-export const runKepler = async (
-  deviceId: string,
-  vpkgPath: string,
-  bundleId: string
-): Promise<void> => {
-  await spawn('kepler', ['run-kepler', vpkgPath, bundleId, '-d', deviceId]);
-};

package/src/platforms/vega/index.ts

@@ -1,107 +0,0 @@
-import {
-  assertVegaRunnerConfig,
-  TestRunnerConfig,
-} from '@react-native-harness/config';
-import { logger } from '@react-native-harness/tools';
-
-import { type PlatformAdapter } from '../platform-adapter.js';
-import {
-  isAppInstalled,
-  getVegaDeviceStatus,
-  isVegaDeviceConnected,
-  startVirtualDevice,
-  stopVirtualDevice,
-  startPortForwarding,
-  stopPortForwarding,
-} from './device.js';
-import { runApp, killApp } from './build.js';
-import { killWithAwait } from '../../process.js';
-import { runMetro } from '../../bundlers/metro.js';
-import { AppNotInstalledError } from '../../errors/errors.js';
-
-const vegaPlatformAdapter: PlatformAdapter = {
-  name: 'vega',
-  getEnvironment: async (runner: TestRunnerConfig) => {
-    assertVegaRunnerConfig(runner);
-
-    let shouldStopVirtualDevice = false;
-
-    // Check if the specific Vega device is available
-    const deviceStatus = await getVegaDeviceStatus(runner.deviceId);
-    logger.debug(`Vega device ${runner.deviceId} status: ${deviceStatus}`);
-
-    if (deviceStatus === 'stopped') {
-      logger.debug('Starting Vega Virtual Device system');
-      await startVirtualDevice();
-      shouldStopVirtualDevice = true;
-
-      // Wait a bit for the device to become available
-      await new Promise((resolve) => setTimeout(resolve, 2000));
-    }
-
-    // Verify device is now connected
-    const isConnected = await isVegaDeviceConnected(runner.deviceId);
-    if (!isConnected) {
-      throw new Error(
-        `Vega device ${runner.deviceId} is not available. Make sure the virtual device is configured and running.`
-      );
-    }
-
-    // Start Metro bundler
-    const metroPromise = runMetro();
-
-    // Set up port forwarding for debugging (similar to Android)
-    await Promise.all([
-      startPortForwarding(runner.deviceId, 8081, false), // reverse port forwarding for JS debugging
-      startPortForwarding(runner.deviceId, 8080, false),
-      startPortForwarding(runner.deviceId, 3001, false),
-    ]);
-    logger.debug('Port forwarding established');
-
-    // Check if app is installed
-    const isInstalled = await isAppInstalled(runner.deviceId, runner.bundleId);
-    logger.debug(`App is installed: ${isInstalled}`);
-
-    if (!isInstalled) {
-      throw new AppNotInstalledError(runner.deviceId, runner.bundleId, 'vega');
-    }
-
-    logger.debug('Waiting for Metro to start');
-    const metro = await metroPromise;
-    logger.debug('Metro started');
-
-    logger.debug('Running Vega app');
-    await runApp(runner.deviceId, runner.bundleId);
-    logger.debug('Vega app running');
-
-    return {
-      restart: async () => {
-        await runApp(runner.deviceId, runner.bundleId);
-      },
-      dispose: async () => {
-        // Kill the app
-        await killApp(runner.deviceId, runner.bundleId);
-
-        // Stop port forwarding
-        await Promise.all([
-          stopPortForwarding(runner.deviceId, 8081, false),
-          stopPortForwarding(runner.deviceId, 8080, false),
-          stopPortForwarding(runner.deviceId, 3001, false),
-        ]).catch((error) => {
-          // Don't fail disposal if port forwarding cleanup fails
-          logger.debug(`Port forwarding cleanup failed: ${error.message}`);
-        });
-
-        // Stop Virtual Device if we started it
-        if (shouldStopVirtualDevice) {
-          await stopVirtualDevice();
-        }
-
-        // Kill Metro
-        await killWithAwait(metro);
-      },
-    };
-  },
-};
-
-export default vegaPlatformAdapter;

package/src/platforms/web/index.ts

@@ -1,16 +0,0 @@
-import {
-  TestRunnerConfig,
-  assertWebRunnerConfig,
-} from '@react-native-harness/config';
-import { PlatformAdapter } from '../platform-adapter.js';
-
-export const webPlatformAdapter: PlatformAdapter = {
-  name: 'web',
-  getEnvironment: async (runner: TestRunnerConfig) => {
-    assertWebRunnerConfig(runner);
-
-    throw new Error('Web platform is currently disabled.');
-  },
-};
-
-export default webPlatformAdapter;

package/src/process.ts

@@ -1,33 +0,0 @@
-import { type ChildProcess } from 'node:child_process';
-
-export const killWithAwait = (child: ChildProcess): Promise<void> => {
-  return new Promise((resolve) => {
-    const timeout = setTimeout(() => {
-      child.kill('SIGTERM');
-      resolve();
-    }, 10000);
-
-    if (child.killed || child.exitCode !== null) {
-      clearTimeout(timeout);
-      resolve();
-      return;
-    }
-
-    child.on('exit', () => {
-      clearTimeout(timeout);
-      resolve();
-    });
-
-    child.on('error', () => {
-      clearTimeout(timeout);
-      resolve();
-    });
-
-    try {
-      child.kill();
-    } catch {
-      clearTimeout(timeout);
-      resolve();
-    }
-  });
-};