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

package/dist/errors/errors.js

@@ -0,0 +1,89 @@
+export class NoRunnerSpecifiedError extends Error {
+    constructor(availableRunners) {
+        super('No runner specified');
+        this.name = 'NoRunnerSpecifiedError';
+        this.availableRunners = availableRunners;
+    }
+    availableRunners;
+}
+export class RunnerNotFoundError extends Error {
+    constructor(runnerName, availableRunners) {
+        super(`Runner "${runnerName}" not found`);
+        this.name = 'RunnerNotFoundError';
+        this.runnerName = runnerName;
+        this.availableRunners = availableRunners;
+    }
+    runnerName;
+    availableRunners;
+}
+export class EnvironmentInitializationError extends Error {
+    constructor(message, runnerName, platform, details) {
+        super(`Failed to initialize environment for "${runnerName}" (${platform}): ${message}`);
+        this.name = 'EnvironmentInitializationError';
+        this.runnerName = runnerName;
+        this.platform = platform;
+        this.details = details;
+    }
+    runnerName;
+    platform;
+    details;
+}
+export class TestExecutionError extends Error {
+    constructor(testFile, error, testSuite, testName) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const suiteInfo = testSuite ? ` in suite "${testSuite}"` : '';
+        const testInfo = testName ? ` test "${testName}"` : '';
+        super(`Test execution failed for ${testFile}${suiteInfo}${testInfo}: ${errorMessage}`);
+        this.name = 'TestExecutionError';
+        this.testFile = testFile;
+        this.testSuite = testSuite;
+        this.testName = testName;
+        this.originalError = error;
+    }
+    testFile;
+    testSuite;
+    testName;
+    originalError;
+}
+export class RpcClientError extends Error {
+    constructor(message, bridgePort, connectionStatus) {
+        const portInfo = bridgePort ? ` (port ${bridgePort})` : '';
+        const statusInfo = connectionStatus ? ` - Status: ${connectionStatus}` : '';
+        super(`RPC client error${portInfo}: ${message}${statusInfo}`);
+        this.name = 'RpcClientError';
+        this.bridgePort = bridgePort;
+        this.connectionStatus = connectionStatus;
+    }
+    bridgePort;
+    connectionStatus;
+}
+export class BridgeTimeoutError extends Error {
+    timeout;
+    runnerName;
+    platform;
+    constructor(timeout, runnerName, platform) {
+        super(`Bridge connection timed out after ${timeout}ms while waiting for "${runnerName}" (${platform}) runner to be ready`);
+        this.timeout = timeout;
+        this.runnerName = runnerName;
+        this.platform = platform;
+        this.name = 'BridgeTimeoutError';
+    }
+}
+export class BundlingFailedError extends Error {
+    modulePath;
+    reason;
+    constructor(modulePath, reason) {
+        super(`Bundling of ${modulePath} failed: ${reason}`);
+        this.modulePath = modulePath;
+        this.reason = reason;
+        this.name = 'BundlingFailedError';
+    }
+}
+export class MetroPortUnavailableError extends Error {
+    port;
+    constructor(port) {
+        super(`Metro port ${port} is not available`);
+        this.port = port;
+        this.name = 'MetroPortUnavailableError';
+    }
+}

package/dist/index.js

@@ -1,10 +1,15 @@
 import { run, yargsOptions } from 'jest-cli';
 import { getConfig } from '@react-native-harness/config';
+import { runInitWizard } from './wizard/index.js';
+import fs from 'node:fs';
+import path from 'node:path';
+const JEST_CONFIG_EXTENSIONS = ['.mjs', '.js', '.cjs'];
+const JEST_HARNESS_CONFIG_BASE = 'jest.harness.config';
 const checkForOldConfig = async () => {
     try {
         const { config } = await getConfig(process.cwd());
         if (config.include) {
-            console.error('\n❌ Migration Required\n');
+            console.error('\n❌ Migration required\n');
             console.error('React Native Harness has migrated to the Jest CLI.');
             console.error('The "include" property in your rn-harness.config file is no longer supported.\n');
             console.error('Please follow the migration guide to update your configuration:');
@@ -19,7 +24,7 @@ const checkForOldConfig = async () => {
 const patchYargsOptions = () => {
     yargsOptions.harnessRunner = {
         type: 'string',
-        description: 'Specify which Harness runner to use',
+        description: 'Specify which harness runner to use',
         requiresArg: true,
     };
     // Remove all options that are not supported by Harness
@@ -57,5 +62,17 @@ const patchYargsOptions = () => {
     delete yargsOptions.coverageProvider;
     delete yargsOptions.logHeapUsage;
 };
-patchYargsOptions();
-checkForOldConfig().then(() => run());
+if (process.argv.includes('init')) {
+    runInitWizard();
+}
+else {
+    patchYargsOptions();
+    const hasConfigArg = process.argv.includes('--config') || process.argv.includes('-c');
+    if (!hasConfigArg) {
+        const existingConfigExt = JEST_CONFIG_EXTENSIONS.find((ext) => fs.existsSync(path.join(process.cwd(), `${JEST_HARNESS_CONFIG_BASE}${ext}`)));
+        if (existingConfigExt) {
+            process.argv.push('--config', `${JEST_HARNESS_CONFIG_BASE}${existingConfigExt}`);
+        }
+    }
+    checkForOldConfig().then(() => run());
+}

package/dist/jest.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jest.d.ts.map

package/dist/jest.d.ts.map

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

package/dist/jest.js

@@ -0,0 +1,7 @@
+import { run, yargsOptions } from 'jest-cli';
+yargsOptions.harnessRunner = {
+    type: 'string',
+    description: 'Specify which Harness runner to use',
+    requiresArg: true,
+};
+run();

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

@@ -1,4 +1,5 @@
-export declare const buildAndroidApp: (deviceId: string, maxRetries?: number) => Promise<void>;
+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) => 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

@@ -1 +1 @@
-{"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"}
+{"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

@@ -1,54 +1,29 @@
-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();
-    });
+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) => {
-    return new Promise((resolve, reject) => {
-        exec(`adb -s ${deviceId} shell am force-stop ${bundleId}`, (error) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
+    await spawn('adb', ['-s', deviceId, 'shell', 'am', 'force-stop', bundleId]);
 };
-export const runApp = async (deviceId, bundleId) => {
+export const runApp = async (deviceId, bundleId, activityName) => {
     await killApp(deviceId, bundleId);
-    return new Promise((resolve, reject) => {
-        exec(`adb -s ${deviceId} shell am start -n ${bundleId}/.MainActivity`, (error) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
+    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

@@ -7,5 +7,4 @@ 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":"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"}
+{"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"}

package/dist/platforms/android/emulator.js

@@ -1,147 +1,116 @@
-import { exec } from 'node:child_process';
+import { spawn } from '@react-native-harness/tools';
 export const getEmulatorNameFromId = async (emulatorId) => {
-    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);
-        });
-    });
+    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) => {
-    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;
-                    }
+    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;
                 }
             }
-            resolve(null);
-        });
-    });
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
 };
-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 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 = (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 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 = (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);
-        });
-    });
+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 = (emulatorId, resolve, reject) => {
+const stopEmulatorById = async (emulatorId) => {
     // Stop the emulator using the found ID
-    exec(`adb -s ${emulatorId} emu kill`, (killError) => {
-        if (killError) {
-            reject(killError);
-            return;
-        }
-        resolve();
-    });
+    await spawn('adb', ['-s', emulatorId, 'emu', 'kill']);
 };
 export const isAppInstalled = async (emulatorId, bundleId) => {
-    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);
-        });
-    });
+    try {
+        const { stdout } = await spawn('adb', [
+            '-s',
+            emulatorId,
+            'shell',
+            'pm',
+            'list',
+            'packages',
+            bundleId,
+        ]);
+        return stdout.trim() !== '';
+    }
+    catch {
+        return false;
+    }
 };
 export const reversePort = async (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);
-        });
-    });
+    await spawn('adb', ['reverse', `tcp:${port}`, `tcp:${port}`]);
 };

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":"AAIA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAY9D,QAAA,MAAM,sBAAsB,EAAE,eAuD7B,CAAC;AAEF,eAAe,sBAAsB,CAAC"}
+{"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

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