@react-native-harness/cli 1.0.0-alpha.9 → 1.0.0-canary.1761046904277

package/src/platforms/vega/device.ts

@@ -0,0 +1,258 @@
+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

@@ -0,0 +1,107 @@
+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/process.ts

@@ -25,7 +25,7 @@ export const killWithAwait = (child: ChildProcess): Promise<void> => {
 
     try {
       child.kill();
-    } catch (error) {
+    } catch {
       clearTimeout(timeout);
       resolve();
     }

package/src/utils.ts

@@ -1,3 +1,5 @@
+import net from 'node:net';
+
 export function assert(condition: boolean, message: string): asserts condition {
   if (!condition) {
     throw new AssertionError(message);
@@ -10,3 +12,18 @@ export class AssertionError extends Error {
     this.name = 'AssertionError';
   }
 }
+
+export const isPortAvailable = (port: number): Promise<boolean> => {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => {
+      server.close();
+      resolve(false);
+    });
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port);
+  });
+};

package/tsconfig.json

@@ -3,6 +3,9 @@
   "files": [],
   "include": [],
   "references": [
+    {
+      "path": "../tools"
+    },
     {
       "path": "../config"
     },