@react-native-harness/cli 1.0.0-alpha.7

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,36 @@
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { testCommand } from './commands/test.js';
+import { handleError } from './errors/errorHandler.js';
+import { logger } from '@react-native-harness/tools';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const program = new Command();
+logger.setVerbose(true);
+program
+    .name('react-native-harness')
+    .description('React Native Test Harness - A comprehensive testing framework for React Native applications')
+    .version(packageJson.version);
+program
+    .command('test')
+    .description('Run tests using the specified runner')
+    .argument('[runner]', 'test runner name (uses defaultRunner from config if not specified)')
+    .argument('[pattern]', 'glob pattern to match test files (uses config.include if not specified)')
+    .action(async (runner, pattern) => {
+    try {
+        await testCommand(runner, pattern);
+    }
+    catch (error) {
+        handleError(error);
+        process.exit(1);
+    }
+});
+process.on('uncaughtException', (error) => {
+    handleError(error);
+    process.exit(1);
+});
+program.parse();

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

@@ -0,0 +1,5 @@
+export declare const buildAndroidApp: () => Promise<void>;
+export declare const installApp: (deviceId: string) => Promise<void>;
+export declare const killApp: (deviceId: string, bundleId: string) => Promise<void>;
+export declare const runApp: (deviceId: string, bundleId: string, activityName: string) => Promise<void>;
+//# sourceMappingURL=build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/platforms/android/build.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe,QAAa,OAAO,CAAC,IAAI,CAEpD,CAAC;AAEF,eAAO,MAAM,UAAU,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,IAAI,CAiB/D,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAEd,CAAC;AAEF,eAAO,MAAM,MAAM,GACjB,UAAU,MAAM,EAChB,UAAU,MAAM,EAChB,cAAc,MAAM,KACnB,OAAO,CAAC,IAAI,CAWd,CAAC"}

package/dist/platforms/android/build.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { spawn } from '@react-native-harness/tools';
+export const buildAndroidApp = async () => {
+    await spawn('react-native', ['build-android', '--tasks', 'assembleDebug']);
+};
+export const installApp = async (deviceId) => {
+    await spawn('adb', [
+        '-s',
+        deviceId,
+        'install',
+        '-r',
+        path.join(process.cwd(), 'android', 'app', 'build', 'outputs', 'apk', 'debug', 'app-debug.apk'),
+    ]);
+};
+export const killApp = async (deviceId, bundleId) => {
+    await spawn('adb', ['-s', deviceId, 'shell', 'am', 'force-stop', bundleId]);
+};
+export const runApp = async (deviceId, bundleId, activityName) => {
+    await killApp(deviceId, bundleId);
+    await spawn('adb', [
+        '-s',
+        deviceId,
+        'shell',
+        'am',
+        'start',
+        '-n',
+        `${bundleId}/${activityName}`,
+    ]);
+};

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

@@ -0,0 +1,5 @@
+export declare const killApp: (deviceId: string, bundleId: string) => Promise<void>;
+export declare const runApp: (deviceId: string, bundleId: string) => Promise<void>;
+export declare const isAppInstalled: (deviceId: string, bundleId: string) => Promise<boolean>;
+export declare const reversePort: (port: number) => Promise<void>;
+//# sourceMappingURL=device.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../../src/platforms/android/device.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,GAClB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAEd,CAAC;AAEF,eAAO,MAAM,MAAM,GACjB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAWd,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAejB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAE5D,CAAC"}

package/dist/platforms/android/device.js

@@ -0,0 +1,36 @@
+import { spawn } from '@react-native-harness/tools';
+export const killApp = async (deviceId, bundleId) => {
+    await spawn('adb', ['-s', deviceId, 'shell', 'am', 'force-stop', bundleId]);
+};
+export const runApp = async (deviceId, bundleId) => {
+    await killApp(deviceId, bundleId);
+    await spawn('adb', [
+        '-s',
+        deviceId,
+        'shell',
+        'am',
+        'start',
+        '-n',
+        `${bundleId}/.MainActivity`,
+    ]);
+};
+export const isAppInstalled = async (deviceId, bundleId) => {
+    try {
+        const { stdout } = await spawn('adb', [
+            '-s',
+            deviceId,
+            'shell',
+            'pm',
+            'list',
+            'packages',
+            bundleId,
+        ]);
+        return stdout.trim() !== '';
+    }
+    catch {
+        return false;
+    }
+};
+export const reversePort = async (port) => {
+    await spawn('adb', ['reverse', `tcp:${port}`, `tcp:${port}`]);
+};

package/dist/platforms/android/emulator.d.ts

@@ -0,0 +1,11 @@
+import { ChildProcess } from 'node:child_process';
+export type AndroidEmulatorStatus = 'running' | 'loading' | 'stopped';
+export declare const getEmulatorNameFromId: (emulatorId: string) => Promise<string | null>;
+export declare const getEmulatorDeviceId: (avdName: string) => Promise<string | null>;
+export declare const getEmulatorStatus: (avdName: string) => Promise<AndroidEmulatorStatus>;
+export declare const runEmulator: (name: string) => Promise<ChildProcess>;
+export declare const stopEmulator: (avdName: string) => Promise<void>;
+export declare const isAppInstalled: (emulatorId: string, bundleId: string) => Promise<boolean>;
+export declare const reversePort: (port: number) => Promise<void>;
+export declare const getEmulatorScreenshot: (emulatorId: string, name?: string) => Promise<string>;
+//# sourceMappingURL=emulator.d.ts.map

package/dist/platforms/android/emulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emulator.d.ts","sourceRoot":"","sources":["../../../src/platforms/android/emulator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEtE,eAAO,MAAM,qBAAqB,GAChC,YAAY,MAAM,KACjB,OAAO,CAAC,MAAM,GAAG,IAAI,CAQvB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,KACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAmBvB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,KACd,OAAO,CAAC,qBAAqB,CAc/B,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,YAAY,CA2BpE,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAQhE,CAAC;AAOF,eAAO,MAAM,cAAc,GACzB,YAAY,MAAM,EAClB,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAOjB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAE5D,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,YAAY,MAAM,EAClB,OAAM,MAGsB,KAC3B,OAAO,CAAC,MAAM,CAchB,CAAC"}

package/dist/platforms/android/emulator.js

@@ -0,0 +1,110 @@
+import { spawn } from '@react-native-harness/tools';
+export const getEmulatorNameFromId = async (emulatorId) => {
+    try {
+        const { stdout } = await spawn('adb', ['-s', emulatorId, 'emu', 'avd', 'name']);
+        const avdName = stdout.split('\n')[0].trim();
+        return avdName || null;
+    }
+    catch {
+        return null;
+    }
+};
+export const getEmulatorDeviceId = async (avdName) => {
+    try {
+        const { stdout } = await spawn('adb', ['devices']);
+        const lines = stdout.split('\n');
+        for (const line of lines) {
+            const parts = line.trim().split('\t');
+            if (parts.length === 2 && parts[0].startsWith('emulator-')) {
+                const emulatorId = parts[0].trim();
+                const name = await getEmulatorNameFromId(emulatorId);
+                if (name === avdName) {
+                    return emulatorId;
+                }
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+export const getEmulatorStatus = async (avdName) => {
+    const emulatorId = await getEmulatorDeviceId(avdName);
+    if (!emulatorId) {
+        return 'stopped';
+    }
+    try {
+        // Check if device is fully booted by checking boot completion
+        const { stdout } = await spawn('adb', ['-s', emulatorId, 'shell', 'getprop', 'sys.boot_completed']);
+        const bootCompleted = stdout.trim() === '1';
+        return bootCompleted ? 'running' : 'loading';
+    }
+    catch {
+        return 'loading';
+    }
+};
+export const runEmulator = async (name) => {
+    // Start the emulator
+    const process = spawn('emulator', ['-avd', name]);
+    const nodeChildProcess = await process.nodeChildProcess;
+    // Poll for emulator status until it's fully running
+    const checkStatus = async () => {
+        const status = await getEmulatorStatus(name);
+        if (status === 'running') {
+            return;
+        }
+        else if (status === 'loading') {
+            // Check again in 2 seconds
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            await checkStatus();
+        }
+        else {
+            // Still stopped, check again in 1 second
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            await checkStatus();
+        }
+    };
+    // Start checking status after a brief delay to allow emulator to start
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    await checkStatus();
+    return nodeChildProcess;
+};
+export const stopEmulator = async (avdName) => {
+    // First, get the emulator device ID
+    const emulatorId = await getEmulatorDeviceId(avdName);
+    if (!emulatorId) {
+        return; // No emulator running, nothing to stop
+    }
+    await stopEmulatorById(emulatorId);
+};
+const stopEmulatorById = async (emulatorId) => {
+    // Stop the emulator using the found ID
+    await spawn('adb', ['-s', emulatorId, 'emu', 'kill']);
+};
+export const isAppInstalled = async (emulatorId, bundleId) => {
+    try {
+        const { stdout } = await spawn('adb', ['-s', emulatorId, 'shell', 'pm', 'list', 'packages', bundleId]);
+        return stdout.trim() !== '';
+    }
+    catch {
+        return false;
+    }
+};
+export const reversePort = async (port) => {
+    await spawn('adb', ['reverse', `tcp:${port}`, `tcp:${port}`]);
+};
+export const getEmulatorScreenshot = async (emulatorId, name = `${emulatorId}-${new Date()
+    .toISOString()
+    .replace(/:/g, '-')
+    .replace(/\//g, '-')}.png`) => {
+    // Use screencap to save directly to device, then pull the file
+    const devicePath = '/sdcard/screenshot.png';
+    // Take screenshot and save to device
+    await spawn('adb', ['-s', emulatorId, 'shell', 'screencap', '-p', devicePath]);
+    // Pull the file from device to local
+    await spawn('adb', ['-s', emulatorId, 'pull', devicePath, name]);
+    // Clean up the file on device
+    await spawn('adb', ['-s', emulatorId, 'shell', 'rm', devicePath]);
+    return name;
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platforms/android/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAa9D,QAAA,MAAM,sBAAsB,EAAE,eAgE7B,CAAC;AAEF,eAAe,sBAAsB,CAAC"}

package/dist/platforms/android/index.js

@@ -0,0 +1,56 @@
+import { assertAndroidRunnerConfig, } from '@react-native-harness/config';
+import { logger } from '@react-native-harness/tools';
+import { runEmulator, getEmulatorDeviceId, reversePort, isAppInstalled, getEmulatorStatus, } from './emulator.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 androidPlatformAdapter = {
+    name: 'android',
+    getEnvironment: async (runner) => {
+        assertAndroidRunnerConfig(runner);
+        let emulator = null;
+        const emulatorStatus = await getEmulatorStatus(runner.deviceId);
+        logger.debug(`Emulator status: ${emulatorStatus}`);
+        const metroPromise = runMetro();
+        if (emulatorStatus === 'stopped') {
+            logger.debug(`Emulator ${runner.deviceId} is stopped, starting it`);
+            emulator = await runEmulator(runner.deviceId);
+        }
+        const deviceId = await getEmulatorDeviceId(runner.deviceId);
+        logger.debug(`Device ID: ${deviceId}`);
+        if (!deviceId) {
+            throw new Error('Emulator not found');
+        }
+        await Promise.all([
+            reversePort(8081),
+            reversePort(8080),
+            reversePort(3001),
+        ]);
+        logger.debug('Ports reversed');
+        const isInstalled = await isAppInstalled(deviceId, runner.bundleId);
+        logger.debug(`App is installed: ${isInstalled}`);
+        if (!isInstalled) {
+            throw new AppNotInstalledError(runner.deviceId, runner.bundleId, 'android');
+        }
+        logger.debug('Waiting for Metro to start');
+        const metro = await metroPromise;
+        logger.debug('Metro started');
+        logger.debug('Running app');
+        await runApp(deviceId, runner.bundleId, runner.activityName);
+        logger.debug('App running');
+        return {
+            restart: async () => {
+                await runApp(runner.deviceId, runner.bundleId, runner.activityName);
+            },
+            dispose: async () => {
+                await killApp(deviceId, runner.bundleId);
+                if (emulator) {
+                    await killWithAwait(emulator);
+                }
+                await killWithAwait(metro);
+            },
+        };
+    },
+};
+export default androidPlatformAdapter;

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

@@ -0,0 +1,7 @@
+export declare const listDevices: () => Promise<any>;
+export declare const getDeviceByName: (simulatorName: string, systemVersion: string) => Promise<any | null>;
+export declare const listApps: (udid: string) => Promise<string[]>;
+export declare const isAppInstalled: (udid: string, bundleId: string) => Promise<boolean>;
+export declare const runApp: (udid: string, appName: string) => Promise<void>;
+export declare const killApp: (udid: string, appName: string) => Promise<void>;
+//# sourceMappingURL=build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/platforms/ios/build.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,GAAG,CAQ/C,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,eAAe,MAAM,EACrB,eAAe,MAAM,KACpB,OAAO,CAAC,GAAG,GAAG,IAAI,CAqBpB,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CAY7D,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,MAAM,MAAM,EACZ,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAGjB,CAAC;AAEF,eAAO,MAAM,MAAM,GAAU,MAAM,MAAM,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAGxE,CAAC;AAEF,eAAO,MAAM,OAAO,GAAU,MAAM,MAAM,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAEzE,CAAC"}

package/dist/platforms/ios/build.js

@@ -0,0 +1,44 @@
+import { spawn, spawnAndForget } from '@react-native-harness/tools';
+export const listDevices = async () => {
+    const { stdout } = await spawn('xcrun', [
+        'simctl',
+        'list',
+        'devices',
+        '--json',
+    ]);
+    return JSON.parse(stdout);
+};
+export const getDeviceByName = async (simulatorName, systemVersion) => {
+    const devices = await listDevices();
+    const expectedRuntimeId = `com.apple.CoreSimulator.SimRuntime.iOS-${systemVersion.replace(/\./, '-')}`;
+    const runtime = devices.devices[expectedRuntimeId];
+    if (!runtime) {
+        return null;
+    }
+    const runtimeDevices = devices.devices[runtime];
+    const device = runtimeDevices.find((d) => d.name === simulatorName);
+    if (device) {
+        return device;
+    }
+    return null;
+};
+export const listApps = async (udid) => {
+    const { stdout: plistOutput } = await spawn('xcrun', [
+        'simctl',
+        'listapps',
+        udid,
+    ]);
+    const { stdout: jsonOutput } = await spawn('plutil', ['-convert', 'json', '-o', '-', '-'], { stdin: { string: plistOutput } });
+    return Object.keys(JSON.parse(jsonOutput));
+};
+export const isAppInstalled = async (udid, bundleId) => {
+    const appList = await listApps(udid);
+    return appList.includes(bundleId);
+};
+export const runApp = async (udid, appName) => {
+    await killApp(udid, appName);
+    await spawn('xcrun', ['simctl', 'launch', udid, appName]);
+};
+export const killApp = async (udid, appName) => {
+    await spawnAndForget('xcrun', ['simctl', 'terminate', udid, appName]);
+};

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

@@ -0,0 +1,7 @@
+export declare const listDevices: () => Promise<any>;
+export declare const getDeviceByName: (simulatorName: string) => Promise<any | null>;
+export declare const listApps: (udid: string) => Promise<string[]>;
+export declare const isAppInstalled: (simulatorName: string, bundleId: string) => Promise<boolean>;
+export declare const runApp: (simulatorName: string, appName: string) => Promise<void>;
+export declare const killApp: (simulatorName: string, appName: string) => Promise<void>;
+//# sourceMappingURL=device.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../../src/platforms/ios/device.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,GAAG,CAQ/C,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,eAAe,MAAM,KACpB,OAAO,CAAC,GAAG,GAAG,IAAI,CAapB,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CAY7D,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,eAAe,MAAM,EACrB,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CASjB,CAAC;AAEF,eAAO,MAAM,MAAM,GACjB,eAAe,MAAM,EACrB,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAGd,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,eAAe,MAAM,EACrB,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAOd,CAAC"}

package/dist/platforms/ios/device.js

@@ -0,0 +1,51 @@
+import { spawn, spawnAndForget } from '@react-native-harness/tools';
+export const listDevices = async () => {
+    const { stdout } = await spawn('xcrun', [
+        'simctl',
+        'list',
+        'devices',
+        '--json',
+    ]);
+    return JSON.parse(stdout);
+};
+export const getDeviceByName = async (simulatorName) => {
+    const devices = await listDevices();
+    for (const runtime in devices.devices) {
+        const runtimeDevices = devices.devices[runtime];
+        for (const device of runtimeDevices) {
+            if (device.name === simulatorName && device.isAvailable) {
+                return device;
+            }
+        }
+    }
+    return null;
+};
+export const listApps = async (udid) => {
+    const { stdout: plistOutput } = await spawn('xcrun', [
+        'simctl',
+        'listapps',
+        udid,
+    ]);
+    const { stdout: jsonOutput } = await spawn('plutil', ['-convert', 'json', '-o', '-', '-'], { stdin: { string: plistOutput } });
+    return Object.keys(JSON.parse(jsonOutput));
+};
+export const isAppInstalled = async (simulatorName, bundleId) => {
+    const device = await getDeviceByName(simulatorName);
+    if (!device) {
+        throw new Error(`Simulator ${simulatorName} not found`);
+    }
+    const appList = await listApps(device.udid);
+    return appList.includes(bundleId);
+};
+export const runApp = async (simulatorName, appName) => {
+    await killApp(simulatorName, appName);
+    await spawn('xcrun', ['simctl', 'launch', simulatorName, appName]);
+};
+export const killApp = async (simulatorName, appName) => {
+    await spawnAndForget('xcrun', [
+        'simctl',
+        'terminate',
+        simulatorName,
+        appName,
+    ]);
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platforms/ios/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAa9D,QAAA,MAAM,kBAAkB,EAAE,eA8CzB,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/platforms/ios/index.js

@@ -0,0 +1,43 @@
+import { assertIOSRunnerConfig, } from '@react-native-harness/config';
+import { getSimulatorDeviceId, getSimulatorStatus, runSimulator, stopSimulator, } from './simulator.js';
+import { isAppInstalled, runApp, killApp } from './build.js';
+import { killWithAwait } from '../../process.js';
+import { runMetro } from '../../bundlers/metro.js';
+import { AppNotInstalledError } from '../../errors/errors.js';
+import { assert } from '../../utils.js';
+const iosPlatformAdapter = {
+    name: 'ios',
+    getEnvironment: async (runner) => {
+        assertIOSRunnerConfig(runner);
+        // TODO: system version is also important as there may be two emulators with the same name
+        // but different system versions
+        let shouldStopSimulator = false;
+        const udid = await getSimulatorDeviceId(runner.deviceId, runner.systemVersion);
+        assert(!!udid, 'Simulator not found');
+        const simulatorStatus = await getSimulatorStatus(udid);
+        const metroPromise = runMetro();
+        if (simulatorStatus === 'stopped') {
+            await runSimulator(udid);
+            shouldStopSimulator = true;
+        }
+        const isInstalled = await isAppInstalled(udid, runner.bundleId);
+        if (!isInstalled) {
+            throw new AppNotInstalledError(runner.deviceId, runner.bundleId, 'ios');
+        }
+        const metro = await metroPromise;
+        await runApp(udid, runner.bundleId);
+        return {
+            restart: async () => {
+                await runApp(udid, runner.bundleId);
+            },
+            dispose: async () => {
+                await killApp(udid, runner.bundleId);
+                if (shouldStopSimulator) {
+                    await stopSimulator(udid);
+                }
+                await killWithAwait(metro);
+            },
+        };
+    },
+};
+export default iosPlatformAdapter;

package/dist/platforms/ios/simulator.d.ts

@@ -0,0 +1,11 @@
+export type IOSSimulatorStatus = 'stopped' | 'loading' | 'running';
+export declare const getSimulatorDeviceId: (simulatorName: string, systemVersion: string) => Promise<string | null>;
+export declare const getAvailableSimulators: () => Promise<Array<{
+    name: string;
+    udid: string;
+    runtime: string;
+}>>;
+export declare const getSimulatorStatus: (udid: string) => Promise<IOSSimulatorStatus>;
+export declare const runSimulator: (udid: string) => Promise<void>;
+export declare const stopSimulator: (udid: string) => Promise<void>;
+//# sourceMappingURL=simulator.d.ts.map

package/dist/platforms/ios/simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulator.d.ts","sourceRoot":"","sources":["../../../src/platforms/ios/simulator.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEnE,eAAO,MAAM,oBAAoB,GAC/B,eAAe,MAAM,EACrB,eAAe,MAAM,KACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CA8BvB,CAAC;AAEF,eAAO,MAAM,sBAAsB,QAAa,OAAO,CACrD,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAmCvD,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,MAAM,MAAM,KACX,OAAO,CAAC,kBAAkB,CAgC5B,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAiC7D,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAE9D,CAAC"}

package/dist/platforms/ios/simulator.js

@@ -0,0 +1,124 @@
+import { spawn } from '@react-native-harness/tools';
+export const getSimulatorDeviceId = async (simulatorName, systemVersion) => {
+    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;
+        }
+        const device = runtime.find((d) => d.name === simulatorName);
+        if (device) {
+            return device.udid;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+export const getAvailableSimulators = async () => {
+    try {
+        const { stdout } = await spawn('xcrun', [
+            'simctl',
+            'list',
+            'devices',
+            '--json',
+        ]);
+        const devices = JSON.parse(stdout);
+        const simulators = [];
+        for (const runtime in devices.devices) {
+            if (runtime.includes('iOS')) {
+                const runtimeDevices = devices.devices[runtime];
+                runtimeDevices.forEach((device) => {
+                    if (device.isAvailable) {
+                        simulators.push({
+                            name: device.name,
+                            udid: device.udid,
+                            runtime: runtime,
+                        });
+                    }
+                });
+            }
+        }
+        return simulators;
+    }
+    catch {
+        return [];
+    }
+};
+export const getSimulatorStatus = async (udid) => {
+    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];
+                const device = runtimeDevices.find((d) => 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) => {
+    try {
+        await spawn('xcrun', ['simctl', 'boot', udid]);
+    }
+    catch (bootError) {
+        // Ignore if simulator is already booted
+        if (!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) => {
+    await stopSimulatorById(udid);
+};
+const stopSimulatorById = async (udid) => {
+    try {
+        await spawn('xcrun', ['simctl', 'shutdown', udid]);
+    }
+    catch (shutdownError) {
+        // Ignore if simulator is already shut down
+        if (!shutdownError.stderr?.includes('Unable to shutdown device in current state: Shutdown')) {
+            throw shutdownError;
+        }
+    }
+};

package/dist/platforms/platform-adapter.d.ts

@@ -0,0 +1,10 @@
+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>;
+};
+//# sourceMappingURL=platform-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"platform-adapter.d.ts","sourceRoot":"","sources":["../../src/platforms/platform-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEhE,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CACpE,CAAC"}

package/dist/platforms/platform-adapter.js

@@ -0,0 +1 @@
+export {};