react-native-harness 0.0.0 → 1.0.0-alpha.2

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Callstack
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# cli
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build cli` to build the library.

package/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import('./dist/index.js');

package/dist/bundlers/metro.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"metro.d.ts","sourceRoot":"","sources":["../../src/bundlers/metro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAWvD,eAAO,MAAM,QAAQ,GAAU,gBAAc,KAAG,OAAO,CAAC,YAAY,CAuCnE,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"}

package/dist/bundlers/metro.js

@@ -0,0 +1,61 @@
+import { getReactNativeCliPath, getExpoCliPath, getTimeoutSignal, spawn, SubprocessError, } from '@react-native-harness/tools';
+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 CLI output
+    metro.nodeChildProcess.then((childProcess) => {
+        if (childProcess.stdout) {
+            childProcess.stdout.pipe(process.stdout);
+        }
+        if (childProcess.stderr) {
+            childProcess.stderr.pipe(process.stderr);
+        }
+    });
+    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;
+        }
+        throw error;
+    });
+    await waitForMetro();
+    return metro.nodeChildProcess;
+};
+export const waitForMetro = async (port = 8081, maxRetries = 20, retryDelay = 1000) => {
+    let attempts = 0;
+    while (attempts < maxRetries) {
+        attempts++;
+        try {
+            const response = await fetch(`http://localhost:${port}/status`, {
+                signal: getTimeoutSignal(100),
+            });
+            if (response.ok) {
+                const body = await response.text();
+                if (body === 'packager-status:running') {
+                    return;
+                }
+            }
+        }
+        catch {
+            // Errors are expected here, we're just waiting for the process to be ready
+        }
+        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`);
+};

package/dist/bundlers/webpack.d.ts

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

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

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

package/dist/bundlers/webpack.js

@@ -0,0 +1,49 @@
+// import { ChildProcess, spawn } from 'node:child_process';
+export {};
+// export const runWebpack = async (configPath: string): Promise<ChildProcess> => {
+//   const webpack = await new Promise<ChildProcess>((resolve) => {
+//     const webpackProcess = spawn(
+//       'webpack',
+//       [
+//         'serve',
+//         '--config',
+//         configPath,
+//         '--mode',
+//         'development',
+//         '--hot',
+//         '--port',
+//         '8081',
+//       ],
+//       {
+//         stdio: 'ignore',
+//         env: {
+//           ...process.env,
+//           RN_HARNESS: 'true',
+//         },
+//       }
+//     );
+//     resolve(webpackProcess);
+//   });
+//   await waitForWebpack(8081);
+//   return webpack;
+// };
+// export const waitForWebpack = async (
+//   port: number = 8081,
+//   maxRetries: number = 10,
+//   retryDelay: number = 2000
+// ): Promise<void> => {
+//   let attempts = 0;
+//   while (attempts < maxRetries) {
+//     attempts++;
+//     try {
+//       const response = await fetch(`http://localhost:${port}`);
+//       if (response.ok) {
+//         return;
+//       }
+//     } catch {}
+//     if (attempts < maxRetries) {
+//       await new Promise((resolve) => setTimeout(resolve, retryDelay));
+//     }
+//   }
+//   throw new Error(`Metro bundler is not ready after ${maxRetries} attempts`);
+// };

package/dist/commands/test.d.ts

@@ -0,0 +1,2 @@
+export declare const testCommand: (runnerName?: string, pattern?: string) => Promise<void>;
+//# sourceMappingURL=test.d.ts.map

package/dist/commands/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/commands/test.ts"],"names":[],"mappings":"AAqJA,eAAO,MAAM,WAAW,GACtB,aAAa,MAAM,EACnB,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAoCd,CAAC"}

package/dist/commands/test.js

@@ -0,0 +1,111 @@
+import { getBridgeServer, } from '@react-native-harness/bridge/server';
+import { getConfig, } from '@react-native-harness/config';
+import { getPlatformAdapter } from '../platforms/platform-registry.js';
+import { Glob } from 'glob';
+import { defaultReporter } from '../reporters/default-reporter.js';
+import { intro, logger, outro, spinner, progress, } from '@react-native-harness/tools';
+import { BridgeTimeoutError } from '../errors/errors.js';
+import { assert } from '../utils.js';
+import { EnvironmentInitializationError, NoRunnerSpecifiedError, RpcClientError, RunnerNotFoundError, } from '../errors/errors.js';
+const setupEnvironment = async (context) => {
+    const startSpinner = spinner();
+    const platform = context.runner.platform;
+    startSpinner.start(`Starting "${context.runner.name}" (${platform}) runner`);
+    const platformAdapter = await getPlatformAdapter(platform);
+    const serverBridge = await getBridgeServer({
+        port: 3001,
+    });
+    context.bridge = serverBridge;
+    const readyPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new BridgeTimeoutError(context.config.bridgeTimeout, context.runner.name, platform));
+        }, context.config.bridgeTimeout);
+        serverBridge.once('ready', () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+    });
+    context.environment = await platformAdapter.getEnvironment(context.runner);
+    logger.debug('Waiting for bridge to be ready');
+    await readyPromise;
+    logger.debug('Bridge is ready');
+    if (!context.environment) {
+        throw new EnvironmentInitializationError('Failed to initialize environment', context.runner.name, platform, 'Platform adapter returned null environment');
+    }
+    startSpinner.stop(`"${context.runner.name}" (${platform}) runner started`);
+};
+const findTestFiles = async (context, pattern) => {
+    const discoverSpinner = spinner();
+    discoverSpinner.start('Discovering tests');
+    const globPattern = pattern || context.config.include;
+    const glob = new Glob(globPattern, {
+        cwd: process.cwd(),
+    });
+    context.testFiles = await glob.walk();
+    discoverSpinner.stop(`Found ${context.testFiles.length} test files`);
+};
+const runTests = async (context) => {
+    const { bridge, environment, testFiles } = context;
+    assert(bridge != null, 'Bridge not initialized');
+    assert(environment != null, 'Environment not initialized');
+    assert(testFiles != null, 'Test files not initialized');
+    let runSpinner = progress({ style: 'block' });
+    runSpinner.start('Running tests');
+    let shouldRestart = false;
+    for (const testFile of testFiles) {
+        if (shouldRestart) {
+            runSpinner = progress({ style: 'block' });
+            runSpinner.message(`Restarting environment for next test file`);
+            await new Promise((resolve) => {
+                bridge.once('ready', resolve);
+                environment.restart();
+            });
+        }
+        runSpinner.message(`Running tests in ${testFile}`);
+        const client = bridge.rpc.clients.at(-1);
+        if (!client) {
+            throw new RpcClientError('No RPC client available', 3001, 'No clients connected');
+        }
+        const result = await client.runTests(testFile);
+        context.results = [...(context.results ?? []), ...result.suites];
+        shouldRestart = true;
+    }
+};
+const cleanUp = async (context) => {
+    if (context.bridge) {
+        context.bridge.ws.close();
+    }
+    if (context.environment) {
+        await context.environment.dispose();
+    }
+};
+export const testCommand = async (runnerName, pattern) => {
+    intro('React Native Test Harness');
+    const config = await getConfig(process.cwd());
+    config.reporter = defaultReporter;
+    const selectedRunnerName = runnerName ?? config.defaultRunner;
+    if (!selectedRunnerName) {
+        throw new NoRunnerSpecifiedError(config.runners);
+    }
+    const runner = config.runners.find((r) => r.name === selectedRunnerName);
+    if (!runner) {
+        throw new RunnerNotFoundError(selectedRunnerName, config.runners);
+    }
+    const context = {
+        config,
+        runner,
+        testFiles: [],
+        results: [],
+    };
+    try {
+        await setupEnvironment(context);
+        await findTestFiles(context, pattern);
+        await runTests(context);
+        assert(context.results != null, 'Results not initialized');
+        config.reporter?.report(context.results);
+        outro('Test run completed successfully');
+    }
+    finally {
+        await cleanUp(context);
+    }
+};

package/dist/errors/appNotInstalledError.d.ts

@@ -0,0 +1,7 @@
+export declare class AppNotInstalledError extends Error {
+    readonly deviceName: string;
+    readonly bundleId: string;
+    readonly platform: 'ios' | 'android';
+    constructor(deviceName: string, bundleId: string, platform: 'ios' | 'android');
+}
+//# sourceMappingURL=appNotInstalledError.d.ts.map

package/dist/errors/appNotInstalledError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appNotInstalledError.d.ts","sourceRoot":"","sources":["../../src/errors/appNotInstalledError.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,SAAQ,KAAK;aAEvB,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM;aAChB,QAAQ,EAAE,KAAK,GAAG,SAAS;gBAF3B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,KAAK,GAAG,SAAS;CAKlD"}

package/dist/errors/appNotInstalledError.js

@@ -0,0 +1,12 @@
+export class AppNotInstalledError extends Error {
+    deviceName;
+    bundleId;
+    platform;
+    constructor(deviceName, bundleId, platform) {
+        super(`App "${bundleId}" is not installed on ${platform === 'ios' ? 'simulator' : 'emulator'} "${deviceName}"`);
+        this.deviceName = deviceName;
+        this.bundleId = bundleId;
+        this.platform = platform;
+        this.name = 'AppNotInstalledError';
+    }
+}

package/dist/errors/bridgeTimeoutError.d.ts

@@ -0,0 +1,7 @@
+export declare class BridgeTimeoutError extends Error {
+    readonly timeout: number;
+    readonly runnerName: string;
+    readonly platform: string;
+    constructor(timeout: number, runnerName: string, platform: string);
+}
+//# sourceMappingURL=bridgeTimeoutError.d.ts.map

package/dist/errors/bridgeTimeoutError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridgeTimeoutError.d.ts","sourceRoot":"","sources":["../../src/errors/bridgeTimeoutError.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,SAAQ,KAAK;aAErB,OAAO,EAAE,MAAM;aACf,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM;gBAFhB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM;CAKvC"}

package/dist/errors/bridgeTimeoutError.js

@@ -0,0 +1,12 @@
+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';
+    }
+}

package/dist/errors/errorHandler.d.ts

@@ -0,0 +1,2 @@
+export declare const handleError: (error: unknown) => void;
+//# sourceMappingURL=errorHandler.d.ts.map

package/dist/errors/errorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.d.ts","sourceRoot":"","sources":["../../src/errors/errorHandler.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,IAuK5C,CAAC"}

package/dist/errors/errorHandler.js

@@ -0,0 +1,138 @@
+import { ConfigLoadError, ConfigNotFoundError, ConfigValidationError, } from '@react-native-harness/config';
+import { AssertionError } from '../utils.js';
+import { NoRunnerSpecifiedError, RunnerNotFoundError, EnvironmentInitializationError, TestExecutionError, RpcClientError, AppNotInstalledError, BridgeTimeoutError, } from './errors.js';
+export const handleError = (error) => {
+    if (error instanceof AssertionError) {
+        console.error(`\n❌ Assertion Error`);
+        console.error(`\nError: ${error.message}`);
+        console.error(`\nPlease check your configuration and try again.`);
+    }
+    else if (error instanceof ConfigValidationError) {
+        console.error(`\n❌ Configuration Error`);
+        console.error(`\nFile: ${error.filePath}`);
+        console.error(`\nValidation errors:`);
+        error.validationErrors.forEach((err) => {
+            console.error(`  • ${err}`);
+        });
+        console.error(`\nPlease fix the configuration errors and try again.`);
+    }
+    else if (error instanceof ConfigNotFoundError) {
+        console.error(`\n❌ Configuration Not Found`);
+        console.error(`\nCould not find 'rn-harness.config' in '${error.searchPath}' or any parent directories.`);
+        console.error(`\nSupported file extensions: .js, .mjs, .cjs, .json`);
+        console.error(`\nPlease create a configuration file or run from a directory that contains one.`);
+    }
+    else if (error instanceof ConfigLoadError) {
+        console.error(`\n❌ Configuration Load Error`);
+        console.error(`\nFile: ${error.filePath}`);
+        console.error(`Error: ${error.message}`);
+        if (error.cause) {
+            console.error(`\nCause: ${error.cause.message}`);
+        }
+        console.error(`\nPlease check your configuration file syntax and try again.`);
+    }
+    else if (error instanceof NoRunnerSpecifiedError) {
+        console.error('\n❌ No runner specified');
+        console.error('\nPlease specify a runner name or set a defaultRunner in your config.');
+        console.error('\nUsage: react-native-harness test [runner-name] [pattern]');
+        console.error('\nAvailable runners:');
+        error.availableRunners.forEach((r) => {
+            console.error(`  • ${r.name} (${r.platform})`);
+        });
+        console.error('\nTo set a default runner, add "defaultRunner" to your config:');
+        console.error('  { "defaultRunner": "your-runner-name" }');
+    }
+    else if (error instanceof RunnerNotFoundError) {
+        console.error(`\n❌ Runner "${error.runnerName}" not found`);
+        console.error('\nAvailable runners:');
+        error.availableRunners.forEach((r) => {
+            console.error(`  • ${r.name} (${r.platform})`);
+        });
+        console.error('\nTo add a new runner, update your rn-harness.config file.');
+    }
+    else if (error instanceof EnvironmentInitializationError) {
+        console.error(`\n❌ Environment Initialization Error`);
+        console.error(`\nRunner: ${error.runnerName} (${error.platform})`);
+        console.error(`\nError: ${error.message}`);
+        if (error.details) {
+            console.error(`\nDetails: ${error.details}`);
+        }
+        console.error(`\nTroubleshooting steps:`);
+        console.error(`  • Verify that ${error.platform} development environment is properly set up`);
+        console.error(`  • Check that the app is built and ready for testing`);
+        console.error(`  • Ensure all required dependencies are installed`);
+        if (error.platform === 'ios') {
+            console.error(`  • Verify Xcode and iOS Simulator are working correctly`);
+        }
+        else if (error.platform === 'android') {
+            console.error(`  • Verify Android SDK and emulator are working correctly`);
+        }
+        console.error(`\nPlease check your environment configuration and try again.`);
+    }
+    else if (error instanceof TestExecutionError) {
+        console.error(`\n❌ Test Execution Error`);
+        console.error(`\nFile: ${error.testFile}`);
+        if (error.testSuite) {
+            console.error(`\nSuite: ${error.testSuite}`);
+        }
+        if (error.testName) {
+            console.error(`\nTest: ${error.testName}`);
+        }
+        console.error(`\nError: ${error.message}`);
+        console.error(`\nTroubleshooting steps:`);
+        console.error(`  • Check the test file syntax and logic`);
+        console.error(`  • Verify all test dependencies are available`);
+        console.error(`  • Ensure the app is in the expected state for the test`);
+        console.error(`  • Check device/emulator logs for additional error details`);
+        console.error(`\nPlease check your test file and try again.`);
+    }
+    else if (error instanceof RpcClientError) {
+        console.error(`\n❌ RPC Client Error`);
+        console.error(`\nError: ${error.message}`);
+        if (error.bridgePort) {
+            console.error(`\nBridge Port: ${error.bridgePort}`);
+        }
+        if (error.connectionStatus) {
+            console.error(`\nConnection Status: ${error.connectionStatus}`);
+        }
+        console.error(`\nTroubleshooting steps:`);
+        console.error(`  • Verify the React Native app is running and connected`);
+        console.error(`  • Check that the bridge port is not blocked by firewall`);
+        console.error(`  • Ensure the app has the React Native Harness runtime integrated`);
+        console.error(`  • Try restarting the app and test harness`);
+        console.error(`\nPlease check your bridge connection and try again.`);
+    }
+    else if (error instanceof AppNotInstalledError) {
+        console.error(`\n❌ App Not Installed`);
+        console.error(`\nThe app "${error.bundleId}" is not installed on ${error.platform === 'ios' ? 'simulator' : 'emulator'} "${error.deviceName}".`);
+        console.error(`\nTo resolve this issue:`);
+        if (error.platform === 'ios') {
+            console.error(`  • Build and install the app: npx react-native run-ios --simulator="${error.deviceName}"`);
+            console.error(`  • Or install from Xcode: Open ios/*.xcworkspace and run the project`);
+        }
+        else {
+            console.error(`  • Build and install the app: npx react-native run-android`);
+            console.error(`  • Or build manually: ./gradlew assembleDebug && adb install android/app/build/outputs/apk/debug/app-debug.apk`);
+        }
+        console.error(`\nPlease install the app and try running the tests again.`);
+    }
+    else if (error instanceof BridgeTimeoutError) {
+        console.error(`\n❌ Bridge Connection Timeout`);
+        console.error(`\nThe bridge connection timed out after ${error.timeout}ms while waiting for the "${error.runnerName}" (${error.platform}) runner to be ready.`);
+        console.error(`\nThis usually indicates that:`);
+        console.error(`  • The React Native app failed to load or connect to the bridge`);
+        console.error(`  • The app crashed during startup`);
+        console.error(`  • Network connectivity issues between the app and the test harness`);
+        console.error(`  • The app is taking longer than expected to initialize`);
+        console.error(`\nTo resolve this issue:`);
+        console.error(`  • Check that the app is properly installed and can start normally`);
+        console.error(`  • Verify that the app has the React Native Harness runtime integrated`);
+        console.error(`  • Check device/emulator logs for any startup errors`);
+        console.error(`  • Ensure the test harness bridge port (3001) is not blocked`);
+        console.error(`\nIf the app needs more time to start, consider increasing the timeout in the configuration.`);
+    }
+    else {
+        console.error(`\n❌ Unexpected Error`);
+        console.error(error);
+    }
+};

package/dist/errors/errors.d.ts

@@ -0,0 +1,41 @@
+import { TestRunnerConfig } from '@react-native-harness/config';
+export declare class NoRunnerSpecifiedError extends Error {
+    constructor(availableRunners: TestRunnerConfig[]);
+    availableRunners: TestRunnerConfig[];
+}
+export declare class RunnerNotFoundError extends Error {
+    constructor(runnerName: string, availableRunners: TestRunnerConfig[]);
+    runnerName: string;
+    availableRunners: TestRunnerConfig[];
+}
+export declare class EnvironmentInitializationError extends Error {
+    constructor(message: string, runnerName: string, platform: string, details?: string);
+    runnerName: string;
+    platform: string;
+    details?: string;
+}
+export declare class TestExecutionError extends Error {
+    constructor(testFile: string, error: unknown, testSuite?: string, testName?: string);
+    testFile: string;
+    testSuite?: string;
+    testName?: string;
+    originalError: unknown;
+}
+export declare class RpcClientError extends Error {
+    constructor(message: string, bridgePort?: number, connectionStatus?: string);
+    bridgePort?: number;
+    connectionStatus?: string;
+}
+export declare class BridgeTimeoutError extends Error {
+    readonly timeout: number;
+    readonly runnerName: string;
+    readonly platform: string;
+    constructor(timeout: number, runnerName: string, platform: string);
+}
+export declare class AppNotInstalledError extends Error {
+    readonly deviceName: string;
+    readonly bundleId: string;
+    readonly platform: 'ios' | 'android';
+    constructor(deviceName: string, bundleId: string, platform: 'ios' | 'android');
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEhE,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,gBAAgB,EAAE,gBAAgB,EAAE;IAKhD,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;CACtC;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,EAAE;IAMpE,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;CACtC;AAED,qBAAa,8BAA+B,SAAQ,KAAK;gBAErD,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM;IAUlB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,kBAAmB,SAAQ,KAAK;gBAEzC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM;IAenB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM;IAS3E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,qBAAa,kBAAmB,SAAQ,KAAK;aAEzB,OAAO,EAAE,MAAM;aACf,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM;gBAFhB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM;CAOnC;AAED,qBAAa,oBAAqB,SAAQ,KAAK;aAE3B,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM;aAChB,QAAQ,EAAE,KAAK,GAAG,SAAS;gBAF3B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,KAAK,GAAG,SAAS;CAS9C"}

package/dist/errors/errors.js

@@ -0,0 +1,83 @@
+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 AppNotInstalledError extends Error {
+    deviceName;
+    bundleId;
+    platform;
+    constructor(deviceName, bundleId, platform) {
+        super(`App "${bundleId}" is not installed on ${platform === 'ios' ? 'simulator' : 'emulator'} "${deviceName}"`);
+        this.deviceName = deviceName;
+        this.bundleId = bundleId;
+        this.platform = platform;
+        this.name = 'AppNotInstalledError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

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,37 @@
+#!/usr/bin/env node
+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();