@react-native-harness/cli 1.0.0-canary.1764675030942 → 1.0.0-canary.1766225407244

package/dist/bundlers/metro.d.ts

@@ -1,5 +1,5 @@
 import { type ChildProcess } from 'node:child_process';
-export declare const runMetro: (isExpo?: boolean) => Promise<ChildProcess>;
+export declare const runMetro: () => Promise<ChildProcess>;
 export declare const waitForMetro: (port?: number, maxRetries?: number, retryDelay?: number) => Promise<void>;
-export declare const reloadApp: () => Promise<void>;
+export declare const reloadApp: (port?: number) => Promise<void>;
 //# sourceMappingURL=metro.d.ts.map

package/dist/bundlers/metro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metro.d.ts","sourceRoot":"","sources":["../../src/bundlers/metro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAcvD,eAAO,MAAM,QAAQ,GAAU,gBAAc,KAAG,OAAO,CAAC,YAAY,CAiDnE,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,aAAW,EACX,mBAAe,EACf,mBAAiB,KAChB,OAAO,CAAC,IAAI,CA4Bd,CAAC;AAEF,eAAO,MAAM,SAAS,QAAa,OAAO,CAAC,IAAI,CAE9C,CAAC"}
+{"version":3,"file":"metro.d.ts","sourceRoot":"","sources":["../../src/bundlers/metro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAS,MAAM,oBAAoB,CAAC;AAQ9D,eAAO,MAAM,QAAQ,QAAa,OAAO,CAAC,YAAY,CAmBrD,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,OAAM,MAAa,EACnB,aAAY,MAAW,EACvB,aAAY,MAAa,KACxB,OAAO,CAAC,IAAI,CA0Bd,CAAC;AAEF,eAAO,MAAM,SAAS,GAAU,aAAW,KAAG,OAAO,CAAC,IAAI,CAEzD,CAAC"}

package/dist/bundlers/metro.js

@@ -1,48 +1,27 @@
-import { getReactNativeCliPath, getExpoCliPath, getTimeoutSignal, spawn, logger, SubprocessError, } from '@react-native-harness/tools';
-import { isPortAvailable } from '../utils.js';
-import { MetroPortUnavailableError } from '../errors/errors.js';
-const METRO_PORT = 8081;
-export const runMetro = async (isExpo = false) => {
-    const metro = spawn('node', [
-        isExpo ? getExpoCliPath() : getReactNativeCliPath(),
-        'start',
-        '--port',
-        METRO_PORT.toString(),
-    ], {
-        env: {
-            ...process.env,
-            RN_HARNESS: 'true',
-            ...(isExpo && { EXPO_NO_METRO_WORKSPACE_ROOT: 'true' }),
-        },
-    });
-    // Forward metro output to logger
-    metro.nodeChildProcess.then((childProcess) => {
-        if (childProcess.stdout) {
-            childProcess.stdout.on('data', (data) => {
-                logger.debug(data.toString().trim());
-            });
-        }
-        if (childProcess.stderr) {
-            childProcess.stderr.on('data', (data) => {
-                logger.debug(data.toString().trim());
-            });
-        }
-    });
-    metro.catch((error) => {
-        // This process is going to be killed by us, so we don't need to throw an error
-        if (error instanceof SubprocessError && error.signalName === 'SIGTERM') {
-            return;
-        }
-        logger.error('Metro crashed unexpectedly', error);
+import { spawn } from 'node:child_process';
+const getTimeoutSignal = (timeout) => {
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), timeout);
+    return controller.signal;
+};
+export const runMetro = async () => {
+    const metro = await new Promise((resolve, reject) => {
+        const metroProcess = spawn('npx', ['react-native', 'start'], {
+            stdio: 'ignore',
+            env: {
+                ...process.env,
+                RN_HARNESS: 'true',
+            },
+        });
+        metroProcess.on('error', (error) => {
+            reject(new Error(`Failed to start Metro: ${error.message}`));
+        });
+        resolve(metroProcess);
     });
-    const isDefaultPortAvailable = await isPortAvailable(METRO_PORT);
-    if (!isDefaultPortAvailable) {
-        throw new MetroPortUnavailableError(METRO_PORT);
-    }
     await waitForMetro();
-    return metro.nodeChildProcess;
+    return metro;
 };
-export const waitForMetro = async (port = 8081, maxRetries = 20, retryDelay = 1000) => {
+export const waitForMetro = async (port = 8081, maxRetries = 10, retryDelay = 1000) => {
     let attempts = 0;
     while (attempts < maxRetries) {
         attempts++;
@@ -57,15 +36,13 @@ export const waitForMetro = async (port = 8081, maxRetries = 20, retryDelay = 10
                 }
             }
         }
-        catch {
-            // Errors are expected here, we're just waiting for the process to be ready
-        }
+        catch { }
         if (attempts < maxRetries) {
             await new Promise((resolve) => setTimeout(resolve, retryDelay));
         }
     }
     throw new Error(`Metro bundler is not ready after ${maxRetries} attempts`);
 };
-export const reloadApp = async () => {
-    await fetch(`http://localhost:${METRO_PORT}/reload`);
+export const reloadApp = async (port = 8081) => {
+    await fetch(`http://localhost:${port}/reload`);
 };

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

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

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

@@ -1 +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"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/platforms/android/build.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAChB,mBAAc,KACb,OAAO,CAAC,IAAI,CAiCd,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAWd,CAAC;AAEF,eAAO,MAAM,MAAM,GACjB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAgBd,CAAC"}

package/dist/platforms/android/build.js

@@ -1,29 +1,54 @@
-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'),
-    ]);
+import { exec } from 'node:child_process';
+import { reloadApp } from '../../bundlers/metro.js';
+export const buildAndroidApp = async (deviceId, maxRetries = 2) => {
+    return new Promise((resolve, reject) => {
+        let attempts = 0;
+        const attemptBuild = () => {
+            attempts++;
+            exec(`react-native run-android --deviceId=${deviceId} --no-packager`, async (error) => {
+                if (error) {
+                    if (attempts <= maxRetries) {
+                        try {
+                            await reloadApp(8081);
+                            // Wait a bit before retrying
+                            setTimeout(attemptBuild, 3000);
+                        }
+                        catch (reloadError) {
+                            console.warn('Reload failed, retrying build anyway...');
+                            setTimeout(attemptBuild, 3000);
+                        }
+                    }
+                    else {
+                        reject(error);
+                    }
+                    return;
+                }
+                resolve();
+            });
+        };
+        attemptBuild();
+    });
 };
 export const killApp = async (deviceId, bundleId) => {
-    await spawn('adb', ['-s', deviceId, 'shell', 'am', 'force-stop', bundleId]);
+    return new Promise((resolve, reject) => {
+        exec(`adb -s ${deviceId} shell am force-stop ${bundleId}`, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
 };
-export const runApp = async (deviceId, bundleId, activityName) => {
+export const runApp = async (deviceId, bundleId) => {
     await killApp(deviceId, bundleId);
-    await spawn('adb', [
-        '-s',
-        deviceId,
-        'shell',
-        'am',
-        'start',
-        '-n',
-        `${bundleId}/${activityName}`,
-    ]);
+    return new Promise((resolve, reject) => {
+        exec(`adb -s ${deviceId} shell am start -n ${bundleId}/.MainActivity`, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
 };

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

@@ -7,4 +7,5 @@ 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

@@ -1 +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,CAcvB,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,CAoB/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,CAejB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAE5D,CAAC"}
+{"version":3,"file":"emulator.d.ts","sourceRoot":"","sources":["../../../src/platforms/android/emulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAQ,MAAM,oBAAoB,CAAC;AAExD,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEtE,eAAO,MAAM,qBAAqB,GAChC,YAAY,MAAM,KACjB,OAAO,CAAC,MAAM,GAAG,IAAI,CAYvB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,KACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAwBvB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,KACd,OAAO,CAAC,qBAAqB,CAuB/B,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,OAAO,CAAC,YAAY,CAgC9D,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAY1D,CAAC;AAiBF,eAAO,MAAM,cAAc,GACzB,YAAY,MAAM,EAClB,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAejB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAW5D,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,YAAY,MAAM,EAClB,OAAM,MAGsB,KAC3B,OAAO,CAAC,MAAM,CAchB,CAAC"}

package/dist/platforms/android/emulator.js

@@ -1,116 +1,147 @@
-import { spawn } from '@react-native-harness/tools';
+import { exec } from 'node:child_process';
 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;
-    }
+    return new Promise((resolve) => {
+        exec(`adb -s ${emulatorId} emu avd name`, (error, stdout) => {
+            if (error) {
+                resolve(null);
+                return;
+            }
+            const avdName = stdout.split('\n')[0].trim();
+            resolve(avdName || 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 new Promise((resolve) => {
+        exec('adb devices', async (error, stdout) => {
+            if (error) {
+                resolve(null);
+                return;
+            }
+            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) {
+                        resolve(emulatorId);
+                        return;
+                    }
                 }
             }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
+            resolve(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 getEmulatorStatus = (avdName) => {
+    return new Promise((resolve) => {
+        getEmulatorDeviceId(avdName).then((emulatorId) => {
+            if (!emulatorId) {
+                resolve('stopped');
+                return;
+            }
+            // Check if device is fully booted by checking boot completion
+            exec(`adb -s ${emulatorId} shell getprop sys.boot_completed`, (bootError, bootStdout) => {
+                if (bootError) {
+                    resolve('loading');
+                    return;
+                }
+                const bootCompleted = bootStdout.trim() === '1';
+                resolve(bootCompleted ? 'running' : '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 runEmulator = (name) => {
+    return new Promise((resolve, reject) => {
+        // Start the emulator
+        const process = exec(`emulator -avd ${name}`, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+        });
+        // Poll for emulator status until it's fully running
+        const checkStatus = async () => {
+            try {
+                const status = await getEmulatorStatus(name);
+                if (status === 'running') {
+                    resolve(process);
+                }
+                else if (status === 'loading') {
+                    // Check again in 2 seconds
+                    setTimeout(checkStatus, 2000);
+                }
+                else {
+                    // Still stopped, check again in 1 second
+                    setTimeout(checkStatus, 1000);
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        // Start checking status after a brief delay to allow emulator to start
+        setTimeout(checkStatus, 3000);
+    });
 };
-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);
+export const stopEmulator = (avdName) => {
+    return new Promise((resolve, reject) => {
+        // First, get the emulator device ID
+        getEmulatorDeviceId(avdName).then((emulatorId) => {
+            if (!emulatorId) {
+                resolve(); // No emulator running, nothing to stop
+                return;
+            }
+            stopEmulatorById(emulatorId, resolve, reject);
+        });
+    });
 };
-const stopEmulatorById = async (emulatorId) => {
+const stopEmulatorById = (emulatorId, resolve, reject) => {
     // Stop the emulator using the found ID
-    await spawn('adb', ['-s', emulatorId, 'emu', 'kill']);
+    exec(`adb -s ${emulatorId} emu kill`, (killError) => {
+        if (killError) {
+            reject(killError);
+            return;
+        }
+        resolve();
+    });
 };
 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;
-    }
+    return new Promise((resolve) => {
+        exec(`adb -s ${emulatorId} shell pm list packages ${bundleId}`, (error, stdout) => {
+            if (error) {
+                resolve(false);
+                return;
+            }
+            const installed = stdout.trim() !== '';
+            resolve(installed);
+        });
+    });
 };
 export const reversePort = async (port) => {
-    await spawn('adb', ['reverse', `tcp:${port}`, `tcp:${port}`]);
+    return new Promise((resolve, reject) => {
+        exec(`adb reverse tcp:${port} tcp:${port}`, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+};
+export const getEmulatorScreenshot = async (emulatorId, name = `${emulatorId}-${new Date()
+    .toISOString()
+    .replace(/:/g, '-')
+    .replace(/\//g, '-')}.png`) => {
+    return new Promise((resolve, reject) => {
+        exec(`adb -s ${emulatorId} exec-out screencap -p > ${name}`, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(name);
+        });
+    });
 };

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platforms/android/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAY9D,QAAA,MAAM,sBAAsB,EAAE,eAuD7B,CAAC;AAEF,eAAe,sBAAsB,CAAC"}

package/dist/platforms/android/index.js

@@ -1,24 +1,21 @@
-import { assertAndroidRunnerConfig, } from '@react-native-harness/config';
-import { logger } from '@react-native-harness/tools';
+import { getAppiumInteractionEngine } from '@react-native-harness/interaction-engine';
+import { assertNativeRunner } from '@react-native-harness/config';
 import { runEmulator, getEmulatorDeviceId, reversePort, isAppInstalled, getEmulatorStatus, } from './emulator.js';
-import { runApp, killApp } from './build.js';
+import { buildAndroidApp, 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);
+    getEnvironment: async (config) => {
+        assertNativeRunner(config);
         let emulator = null;
-        const emulatorStatus = await getEmulatorStatus(runner.deviceId);
-        logger.debug(`Emulator status: ${emulatorStatus}`);
+        const emulatorStatus = await getEmulatorStatus(config.runner.deviceId);
         const metroPromise = runMetro();
         if (emulatorStatus === 'stopped') {
-            logger.debug(`Emulator ${runner.deviceId} is stopped, starting it`);
-            emulator = await runEmulator(runner.deviceId);
+            emulator = await runEmulator(config.runner.deviceId);
         }
-        const deviceId = await getEmulatorDeviceId(runner.deviceId);
-        logger.debug(`Device ID: ${deviceId}`);
+        const interactionEnginePromise = getAppiumInteractionEngine(config);
+        const deviceId = await getEmulatorDeviceId(config.runner.deviceId);
         if (!deviceId) {
             throw new Error('Emulator not found');
         }
@@ -27,29 +24,28 @@ const androidPlatformAdapter = {
             reversePort(8080),
             reversePort(3001),
         ]);
-        logger.debug('Ports reversed');
-        const isInstalled = await isAppInstalled(deviceId, runner.bundleId);
-        logger.debug(`App is installed: ${isInstalled}`);
+        const isInstalled = await isAppInstalled(deviceId, config.runner.bundleId);
         if (!isInstalled) {
-            throw new AppNotInstalledError(runner.deviceId, runner.bundleId, 'android');
+            await buildAndroidApp(deviceId);
         }
-        logger.debug('Waiting for Metro to start');
+        else {
+            await runApp(deviceId, config.runner.bundleId);
+        }
+        const interactionEngine = await interactionEnginePromise;
         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(deviceId, runner.bundleId, runner.activityName);
+                await runApp(config.runner.deviceId, config.runner.bundleId);
             },
             dispose: async () => {
-                await killApp(deviceId, runner.bundleId);
                 if (emulator) {
                     await killWithAwait(emulator);
                 }
+                await interactionEngine.close();
                 await killWithAwait(metro);
+                await killApp(deviceId, config.runner.bundleId);
             },
+            interactionEngine,
         };
     },
 };

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

@@ -1,7 +1,9 @@
 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>;
+export declare const getDeviceByName: (simulatorName: string) => Promise<any | null>;
+export declare const installPods: () => Promise<void>;
+export declare const listApps: (udid: string) => Promise<string>;
+export declare const isAppInstalled: (simulatorName: string, bundleId: string) => Promise<boolean>;
+export declare const buildIOSApp: (simulatorName: string, maxRetries?: number) => Promise<void>;
+export declare const runApp: (simulatorName: string, appName: string) => Promise<void>;
+export declare const killApp: (simulatorName: string, appName: string) => Promise<void>;
 //# sourceMappingURL=build.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/platforms/ios/build.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,GAAG,CAQ/C,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,eAAe,MAAM,EACrB,eAAe,MAAM,KAEpB,OAAO,CAAC,GAAG,GAAG,IAAI,CAsBpB,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"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/platforms/ios/build.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,GAAG,CAgB/C,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,eAAe,MAAM,KACpB,OAAO,CAAC,GAAG,GAAG,IAAI,CAiBpB,CAAC;AAEF,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,IAAI,CAYhD,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,MAAM,CAW3D,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,eAAe,MAAM,EACrB,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAajB,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,eAAe,MAAM,EACrB,aAAY,MAAU,KACrB,OAAO,CAAC,IAAI,CAoCd,CAAC;AAEF,eAAO,MAAM,MAAM,GACjB,eAAe,MAAM,EACrB,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAgBd,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,eAAe,MAAM,EACrB,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAMd,CAAC"}