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

package/dist/platforms/ios/simulator.js

@@ -1,4 +1,4 @@
-import { spawn } from '@react-native-harness/tools';
+import { spawn, SubprocessError } from '@react-native-harness/tools';
 export const getSimulatorDeviceId = async (simulatorName, systemVersion) => {
     try {
         const { stdout } = await spawn('xcrun', [
@@ -13,6 +13,7 @@ export const getSimulatorDeviceId = async (simulatorName, systemVersion) => {
         if (!runtime) {
             return null;
         }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const device = runtime.find((d) => d.name === simulatorName);
         if (device) {
             return device.udid;
@@ -36,6 +37,7 @@ export const getAvailableSimulators = async () => {
         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) => {
                     if (device.isAvailable) {
                         simulators.push({
@@ -65,6 +67,7 @@ export const getSimulatorStatus = async (udid) => {
         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) => d.udid === udid);
                 if (device) {
                     switch (device.state) {
@@ -90,7 +93,8 @@ export const runSimulator = async (udid) => {
     }
     catch (bootError) {
         // Ignore if simulator is already booted
-        if (!bootError.stderr?.includes('Unable to boot device in current state: Booted')) {
+        if (bootError instanceof SubprocessError &&
+            !bootError.stderr?.includes('Unable to boot device in current state: Booted')) {
             throw bootError;
         }
     }
@@ -117,7 +121,8 @@ const stopSimulatorById = async (udid) => {
     }
     catch (shutdownError) {
         // Ignore if simulator is already shut down
-        if (!shutdownError.stderr?.includes('Unable to shutdown device in current state: Shutdown')) {
+        if (shutdownError instanceof SubprocessError &&
+            !shutdownError.stderr?.includes('Unable to shutdown device in current state: Shutdown')) {
             throw shutdownError;
         }
     }

package/dist/platforms/platform-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform-registry.d.ts","sourceRoot":"","sources":["../../src/platforms/platform-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAWxD,eAAO,MAAM,kBAAkB,GAC7B,cAAc,MAAM,KACnB,OAAO,CAAC,eAAe,CAUzB,CAAC"}
+{"version":3,"file":"platform-registry.d.ts","sourceRoot":"","sources":["../../src/platforms/platform-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAaxD,eAAO,MAAM,kBAAkB,GAC7B,cAAc,MAAM,KACnB,OAAO,CAAC,eAAe,CAUzB,CAAC"}

package/dist/platforms/platform-registry.js

@@ -1,10 +1,12 @@
 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) => {
     if (!(platformName in platformAdapters)) {
@@ -13,7 +15,7 @@ export const getPlatformAdapter = async (platformName) => {
     try {
         return platformAdapters[platformName];
     }
-    catch (error) {
+    catch {
         throw new Error(`Platform adapter for ${platformName} not found`);
     }
 };

package/dist/platforms/vega/build.d.ts

@@ -0,0 +1,23 @@
+export type VegaBuildTarget = 'sim_tv_x86_64' | 'sim_tv_aarch64';
+export type VegaBuildType = 'Debug' | 'Release';
+/**
+ * Build Vega app and produce .vpkg file
+ */
+export declare const buildVegaApp: (buildType?: VegaBuildType, target?: VegaBuildTarget) => Promise<void>;
+/**
+ * Clean build artifacts
+ */
+export declare const cleanBuild: () => Promise<void>;
+/**
+ * Get the expected .vpkg file path based on build configuration
+ */
+export declare const getVpkgPath: (appName: string, buildType?: VegaBuildType, target?: VegaBuildTarget) => string;
+/**
+ * Launch an already installed app on specified Vega virtual device
+ */
+export declare const runApp: (deviceId: string, bundleId: string) => Promise<void>;
+/**
+ * Kill/terminate app on specified Vega virtual device
+ */
+export declare const killApp: (deviceId: string, bundleId: string) => Promise<void>;
+//# sourceMappingURL=build.d.ts.map

package/dist/platforms/vega/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/platforms/vega/build.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG,gBAAgB,CAAC;AACjE,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,YAAY,GACvB,YAAW,aAAyB,EACpC,SAAS,eAAe,KACvB,OAAO,CAAC,IAAI,CAYd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,QAAa,OAAO,CAAC,IAAI,CAE/C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,GACtB,SAAS,MAAM,EACf,YAAW,aAAyB,EACpC,SAAQ,eAAiC,KACxC,MAUF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,GACjB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CASd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,GAClB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CASd,CAAC"}

package/dist/platforms/vega/build.js

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { spawn } from '@react-native-harness/tools';
+/**
+ * Build Vega app and produce .vpkg file
+ */
+export const buildVegaApp = async (buildType = 'Release', target) => {
+    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 () => {
+    await spawn('kepler', ['clean']);
+};
+/**
+ * Get the expected .vpkg file path based on build configuration
+ */
+export const getVpkgPath = (appName, buildType = 'Release', target = 'sim_tv_x86_64') => {
+    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, bundleId) => {
+    await spawn('kepler', [
+        'device',
+        'launch-app',
+        '--device',
+        deviceId,
+        '--appName',
+        bundleId,
+    ]);
+};
+/**
+ * Kill/terminate app on specified Vega virtual device
+ */
+export const killApp = async (deviceId, bundleId) => {
+    await spawn('kepler', [
+        'device',
+        'terminate-app',
+        '--device',
+        deviceId,
+        '--appName',
+        bundleId,
+    ]);
+};

package/dist/platforms/vega/device.d.ts

@@ -0,0 +1,57 @@
+export type VegaVirtualDeviceStatus = 'running' | 'stopped';
+/**
+ * List all available Vega virtual devices
+ * Returns array of device identifiers that can be used with kepler commands
+ */
+export declare const listVegaDevices: () => Promise<string[]>;
+/**
+ * Check if a specific Vega virtual device is connected/available
+ */
+export declare const isVegaDeviceConnected: (deviceId: string) => Promise<boolean>;
+/**
+ * Check if an app is installed on the specified Vega virtual device
+ */
+export declare const isAppInstalled: (deviceId: string, bundleId: string) => Promise<boolean>;
+/**
+ * Check if an app is currently running on the specified Vega virtual device
+ */
+export declare const isAppRunning: (deviceId: string, bundleId: string) => Promise<boolean>;
+/**
+ * Install app on specified Vega virtual device using .vpkg file
+ */
+export declare const installApp: (deviceId: string, vpkgPath: string) => Promise<void>;
+/**
+ * Terminate app on specified Vega virtual device
+ */
+export declare const terminateApp: (deviceId: string, bundleId: string) => Promise<void>;
+/**
+ * Uninstall app from specified Vega virtual device
+ */
+export declare const uninstallApp: (deviceId: string, bundleId: string) => Promise<void>;
+/**
+ * Start port forwarding for debugging on specified Vega virtual device
+ */
+export declare const startPortForwarding: (deviceId: string, port: number, forward?: boolean) => Promise<void>;
+/**
+ * Stop port forwarding on specified Vega virtual device
+ */
+export declare const stopPortForwarding: (deviceId: string, port: number, forward?: boolean) => Promise<void>;
+/**
+ * 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 declare const getVegaDeviceStatus: (deviceId: string) => Promise<VegaVirtualDeviceStatus>;
+/**
+ * Start Vega Virtual Device
+ * Note: Vega might manage virtual devices globally, this starts the virtual device system
+ */
+export declare const startVirtualDevice: () => Promise<void>;
+/**
+ * Stop Vega Virtual Device
+ */
+export declare const stopVirtualDevice: () => Promise<void>;
+/**
+ * Combined install and run command for specified Vega virtual device (Vega-specific convenience method)
+ */
+export declare const runKepler: (deviceId: string, vpkgPath: string, bundleId: string) => Promise<void>;
+//# sourceMappingURL=device.d.ts.map

package/dist/platforms/vega/device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../../src/platforms/vega/device.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,SAAS,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAa,OAAO,CAAC,MAAM,EAAE,CAwBxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAChC,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAYjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GACzB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAcjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,GACvB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAcjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CASd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,GACvB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CASd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,GACvB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CASd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAC9B,UAAU,MAAM,EAChB,MAAM,MAAM,EACZ,iBAAc,KACb,OAAO,CAAC,IAAI,CAWd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAU,MAAM,EAChB,MAAM,MAAM,EACZ,iBAAc,KACb,OAAO,CAAC,IAAI,CAWd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,UAAU,MAAM,KACf,OAAO,CAAC,uBAAuB,CAkBjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAa,OAAO,CAAC,IAAI,CAqBvD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,IAAI,CAEtD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,GACpB,UAAU,MAAM,EAChB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAEd,CAAC"}

package/dist/platforms/vega/device.js

@@ -0,0 +1,206 @@
+import { spawn } from '@react-native-harness/tools';
+/**
+ * List all available Vega virtual devices
+ * Returns array of device identifiers that can be used with kepler commands
+ */
+export const listVegaDevices = async () => {
+    try {
+        const { stdout } = await spawn('kepler', ['device', 'list']);
+        const lines = stdout.trim().split('\n');
+        const devices = [];
+        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) => {
+    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, bundleId) => {
+    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, bundleId) => {
+    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, vpkgPath) => {
+    await spawn('kepler', [
+        'device',
+        'install-app',
+        '-p',
+        vpkgPath,
+        '--device',
+        deviceId,
+    ]);
+};
+/**
+ * Terminate app on specified Vega virtual device
+ */
+export const terminateApp = async (deviceId, bundleId) => {
+    await spawn('kepler', [
+        'device',
+        'terminate-app',
+        '--device',
+        deviceId,
+        '--appName',
+        bundleId,
+    ]);
+};
+/**
+ * Uninstall app from specified Vega virtual device
+ */
+export const uninstallApp = async (deviceId, bundleId) => {
+    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, port, forward = true) => {
+    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, port, forward = true) => {
+    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) => {
+    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 () => {
+    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 () => {
+    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, vpkgPath, bundleId) => {
+    await spawn('kepler', ['run-kepler', vpkgPath, bundleId, '-d', deviceId]);
+};

package/dist/platforms/vega/index.d.ts

@@ -0,0 +1,4 @@
+import { type PlatformAdapter } from '../platform-adapter.js';
+declare const vegaPlatformAdapter: PlatformAdapter;
+export default vegaPlatformAdapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/platforms/vega/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platforms/vega/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAe9D,QAAA,MAAM,mBAAmB,EAAE,eAmF1B,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/platforms/vega/index.js

@@ -0,0 +1,75 @@
+import { assertVegaRunnerConfig, } from '@react-native-harness/config';
+import { logger } from '@react-native-harness/tools';
+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 = {
+    name: 'vega',
+    getEnvironment: async (runner) => {
+        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/dist/process.js

@@ -20,7 +20,7 @@ export const killWithAwait = (child) => {
         try {
             child.kill();
         }
-        catch (error) {
+        catch {
             clearTimeout(timeout);
             resolve();
         }