@react-native-harness/cli 1.1.0 → 1.2.0

package/dist/errors/errorHandler.js

@@ -0,0 +1,152 @@
+import { ConfigLoadError, ConfigNotFoundError, ConfigValidationError, } from '@react-native-harness/config';
+import { AssertionError } from '../utils.js';
+import { NoRunnerSpecifiedError, RunnerNotFoundError, EnvironmentInitializationError, TestExecutionError, RpcClientError, BridgeTimeoutError, BundlingFailedError, MetroPortUnavailableError, } from './errors.js';
+export const formatError = (error) => {
+    const lines = [];
+    if (error instanceof AssertionError) {
+        lines.push(`\n❌ Assertion Error`);
+        lines.push(`\nError: ${error.message}`);
+        lines.push(`\nPlease check your configuration and try again.`);
+    }
+    else if (error instanceof ConfigValidationError) {
+        lines.push(`\n❌ Configuration Error`);
+        lines.push(`\nFile: ${error.filePath}`);
+        lines.push(`\nValidation errors:`);
+        error.validationErrors.forEach((err) => {
+            lines.push(`  • ${err}`);
+        });
+        lines.push(`\nPlease fix the configuration errors and try again.`);
+    }
+    else if (error instanceof ConfigNotFoundError) {
+        lines.push(`\n❌ Configuration Not Found`);
+        lines.push(`\nCould not find 'rn-harness.config' in '${error.searchPath}' or any parent directories.`);
+        lines.push(`\nSupported file extensions: .js, .mjs, .cjs, .json`);
+        lines.push(`\nPlease create a configuration file or run from a directory that contains one.`);
+    }
+    else if (error instanceof ConfigLoadError) {
+        lines.push(`\n❌ Configuration Load Error`);
+        lines.push(`\nFile: ${error.filePath}`);
+        lines.push(`Error: ${error.message}`);
+        if (error.cause) {
+            lines.push(`\nCause: ${error.cause.message}`);
+        }
+        lines.push(`\nPlease check your configuration file syntax and try again.`);
+    }
+    else if (error instanceof NoRunnerSpecifiedError) {
+        lines.push('\n❌ No runner specified');
+        lines.push('\nPlease specify a runner name or set a defaultRunner in your config.');
+        lines.push('\nUsage: react-native-harness test [runner-name] [pattern]');
+        lines.push('\nAvailable runners:');
+        error.availableRunners.forEach((r) => {
+            lines.push(`  • ${r.name} (${r.platform})`);
+        });
+        lines.push('\nTo set a default runner, add "defaultRunner" to your config:');
+        lines.push('  { "defaultRunner": "your-runner-name" }');
+    }
+    else if (error instanceof RunnerNotFoundError) {
+        lines.push(`\n❌ Runner "${error.runnerName}" not found`);
+        lines.push('\nAvailable runners:');
+        error.availableRunners.forEach((r) => {
+            lines.push(`  • ${r.name} (${r.platform})`);
+        });
+        lines.push('\nTo add a new runner, update your rn-harness.config file.');
+    }
+    else if (error instanceof EnvironmentInitializationError) {
+        lines.push(`\n❌ Environment Initialization Error`);
+        lines.push(`\nRunner: ${error.runnerName} (${error.platform})`);
+        lines.push(`\nError: ${error.message}`);
+        if (error.details) {
+            lines.push(`\nDetails: ${error.details}`);
+        }
+        lines.push(`\nTroubleshooting steps:`);
+        lines.push(`  • Verify that ${error.platform} development environment is properly set up`);
+        lines.push(`  • Check that the app is built and ready for testing`);
+        lines.push(`  • Ensure all required dependencies are installed`);
+        if (error.platform === 'ios') {
+            lines.push(`  • Verify Xcode and iOS Simulator are working correctly`);
+        }
+        else if (error.platform === 'android') {
+            lines.push(`  • Verify Android SDK and emulator are working correctly`);
+        }
+        lines.push(`\nPlease check your environment configuration and try again.`);
+    }
+    else if (error instanceof TestExecutionError) {
+        lines.push(`\n❌ Test Execution Error`);
+        lines.push(`\nFile: ${error.testFile}`);
+        if (error.testSuite) {
+            lines.push(`\nSuite: ${error.testSuite}`);
+        }
+        if (error.testName) {
+            lines.push(`\nTest: ${error.testName}`);
+        }
+        lines.push(`\nError: ${error.message}`);
+        lines.push(`\nTroubleshooting steps:`);
+        lines.push(`  • Check the test file syntax and logic`);
+        lines.push(`  • Verify all test dependencies are available`);
+        lines.push(`  • Ensure the app is in the expected state for the test`);
+        lines.push(`  • Check device/emulator logs for additional error details`);
+        lines.push(`\nPlease check your test file and try again.`);
+    }
+    else if (error instanceof RpcClientError) {
+        lines.push(`\n❌ RPC Client Error`);
+        lines.push(`\nError: ${error.message}`);
+        if (error.bridgePort) {
+            lines.push(`\nBridge Port: ${error.bridgePort}`);
+        }
+        if (error.connectionStatus) {
+            lines.push(`\nConnection Status: ${error.connectionStatus}`);
+        }
+        lines.push(`\nTroubleshooting steps:`);
+        lines.push(`  • Verify the React Native app is running and connected`);
+        lines.push(`  • Check that the bridge port is not blocked by firewall`);
+        lines.push(`  • Ensure the app has the React Native Harness runtime integrated`);
+        lines.push(`  • Try restarting the app and test harness`);
+        lines.push(`\nPlease check your bridge connection and try again.`);
+    }
+    else if (error instanceof BundlingFailedError) {
+        lines.push(`\n❌ Test File Bundling Error`);
+        lines.push(`\nFile: ${error.modulePath}`);
+        lines.push(`\nError: ${error.reason}`);
+        lines.push(`\nTroubleshooting steps:`);
+        lines.push(`  • Check the test file syntax and imports`);
+        lines.push(`  • Verify all imported modules exist and are accessible`);
+        lines.push(`  • Ensure the Metro bundler configuration is correct`);
+        lines.push(`  • Check for any circular dependencies in the test file`);
+        lines.push(`  • Verify that all required packages are installed`);
+        lines.push(`\nPlease fix the bundling issues and try again.`);
+    }
+    else if (error instanceof BridgeTimeoutError) {
+        lines.push(`\n❌ Bridge Connection Timeout`);
+        lines.push(`\nThe bridge connection timed out after ${error.timeout}ms while waiting for the "${error.runnerName}" (${error.platform}) runner to be ready.`);
+        lines.push(`\nThis usually indicates that:`);
+        lines.push(`  • The React Native app failed to load or connect to the bridge`);
+        lines.push(`  • The app crashed during startup`);
+        lines.push(`  • Network connectivity issues between the app and the test harness`);
+        lines.push(`  • The app is taking longer than expected to initialize`);
+        lines.push(`\nTo resolve this issue:`);
+        lines.push(`  • Check that the app is properly installed and can start normally`);
+        lines.push(`  • Verify that the app has the React Native Harness runtime integrated`);
+        lines.push(`  • Check device/emulator logs for any startup errors`);
+        lines.push(`  • Ensure the test harness bridge port (3001) is not blocked`);
+        lines.push(`\nIf the app needs more time to start, consider increasing the timeout in the configuration.`);
+    }
+    else if (error instanceof MetroPortUnavailableError) {
+        lines.push(`\n❌ Metro Port Unavailable`);
+        lines.push(`\nPort ${error.port} is already in use or unavailable.`);
+        lines.push(`\nThis usually indicates that:`);
+        lines.push(`  • Another Metro bundler instance is already running`);
+        lines.push(`  • Another application is using port ${error.port}`);
+        lines.push(`  • The port is blocked by a firewall or security software`);
+        lines.push(`\nTo resolve this issue:`);
+        lines.push(`  • Stop any running Metro bundler instances`);
+        lines.push(`  • Check for other applications using port ${error.port}: lsof -i :${error.port}`);
+        lines.push(`  • Kill the process using the port: kill -9 <PID>`);
+        lines.push(`  • Or use a different port by updating your Metro configuration`);
+        lines.push(`\nPlease free up the port and try again.`);
+    }
+    else {
+        // Re-throw the error to be handled by the caller
+        throw error;
+    }
+    return lines.join('');
+};

package/dist/errors/errors.d.ts

@@ -0,0 +1,45 @@
+type TestRunnerConfig = any;
+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 BundlingFailedError extends Error {
+    readonly modulePath: string;
+    readonly reason: string;
+    constructor(modulePath: string, reason: string);
+}
+export declare class MetroPortUnavailableError extends Error {
+    readonly port: number;
+    constructor(port: number);
+}
+export {};
+//# 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,KAAK,gBAAgB,GAAG,GAAG,CAAC;AAE5B,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,mBAAoB,SAAQ,KAAK;aAE1B,UAAU,EAAE,MAAM;aAClB,MAAM,EAAE,MAAM;gBADd,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM;CAKjC;AAED,qBAAa,yBAA0B,SAAQ,KAAK;aACtB,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAIzC"}

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,101 @@
 import { run, yargsOptions } from 'jest-cli';
 import { getConfig } from '@react-native-harness/config';
 import { runInitWizard } from './wizard/index.js';
+import { runPlatformCommand } from './platform-commands.js';
 import fs from 'node:fs';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 const JEST_CONFIG_EXTENSIONS = ['.mjs', '.js', '.cjs'];
 const JEST_HARNESS_CONFIG_BASE = 'jest.harness.config';
+const SKILLS_DIRECTORY = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../skills');
+const readSkillMetadata = (fileName) => {
+    const filePath = path.join(SKILLS_DIRECTORY, fileName);
+    const content = fs.readFileSync(filePath, 'utf8');
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    const metadata = {
+        name: fileName.replace(/\.md$/, ''),
+        description: '',
+    };
+    if (frontmatterMatch) {
+        for (const line of frontmatterMatch[1].split('\n')) {
+            const separatorIndex = line.indexOf(':');
+            if (separatorIndex === -1) {
+                continue;
+            }
+            const key = line.slice(0, separatorIndex).trim();
+            const value = line.slice(separatorIndex + 1).trim().replace(/^['"]|['"]$/g, '');
+            if (key === 'name') {
+                metadata.name = value;
+            }
+            if (key === 'description') {
+                metadata.description = value;
+            }
+        }
+    }
+    return {
+        fileName,
+        name: metadata.name,
+        description: metadata.description,
+    };
+};
+const listSkills = () => fs
+    .readdirSync(SKILLS_DIRECTORY)
+    .filter((file) => file.endsWith('.md'))
+    .map(readSkillMetadata)
+    .sort((left, right) => left.name.localeCompare(right.name));
+const printSkillList = () => {
+    for (const skill of listSkills()) {
+        console.log(`${skill.name}: ${skill.description}`);
+    }
+};
+const printSkillUsage = () => {
+    console.log(`Usage: harness skill <command>
+
+Commands:
+  list                 List bundled skills
+  get <name>           Print a bundled skill file
+
+Examples:
+  harness skill list
+  harness skill get core`);
+};
+const getErrorMessage = (error) => {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+};
+const runSkillCommand = () => {
+    const [, , commandName, subcommand, skillName] = process.argv;
+    if (subcommand === undefined || subcommand === 'list') {
+        printSkillList();
+        return;
+    }
+    if (subcommand === '--help' || subcommand === '-h') {
+        printSkillUsage();
+        return;
+    }
+    if (subcommand === 'get') {
+        if (!skillName) {
+            console.error('Missing skill name.');
+            printSkillUsage();
+            process.exit(1);
+        }
+        const skillPath = path.join(SKILLS_DIRECTORY, `${skillName}.md`);
+        if (!fs.existsSync(skillPath)) {
+            console.error(`Unknown skill '${skillName}'.`);
+            console.error(`Available skills: ${listSkills()
+                .map((skill) => skill.name)
+                .join(', ')}`);
+            process.exit(1);
+        }
+        console.log(fs.readFileSync(skillPath, 'utf8'));
+        return;
+    }
+    console.error(`Unknown ${commandName} subcommand '${subcommand}'.`);
+    printSkillUsage();
+    process.exit(1);
+};
 const checkForOldConfig = async () => {
     try {
         const { config } = await getConfig(process.cwd());
@@ -62,10 +153,21 @@ const patchYargsOptions = () => {
     delete yargsOptions.coverageProvider;
     delete yargsOptions.logHeapUsage;
 };
-if (process.argv.includes('init')) {
-    runInitWizard();
-}
-else {
+const main = async () => {
+    if (process.argv[2] === 'skill' || process.argv[2] === 'skills') {
+        runSkillCommand();
+        return;
+    }
+    if (process.argv.includes('init')) {
+        runInitWizard();
+        return;
+    }
+    if (await runPlatformCommand({
+        argv: process.argv.slice(2),
+        cwd: process.cwd(),
+    })) {
+        return;
+    }
     patchYargsOptions();
     const hasConfigArg = process.argv.includes('--config') || process.argv.includes('-c');
     if (!hasConfigArg) {
@@ -74,5 +176,10 @@ else {
             process.argv.push('--config', `${JEST_HARNESS_CONFIG_BASE}${existingConfigExt}`);
         }
     }
-    checkForOldConfig().then(() => run());
-}
+    await checkForOldConfig();
+    run();
+};
+main().catch((error) => {
+    console.error(getErrorMessage(error));
+    process.exit(1);
+});

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/platform-commands.d.ts

@@ -0,0 +1,18 @@
+import { getConfig } from '@react-native-harness/config';
+import type { HarnessCliCommand } from '@react-native-harness/platforms';
+type ConfigLoader = typeof getConfig;
+type DiscoveredPlatformCommands = {
+    commands: HarnessCliCommand[];
+    projectRoot: string;
+};
+export declare const discoverPlatformCommands: (options: {
+    cwd: string;
+    loadConfig?: ConfigLoader;
+}) => Promise<DiscoveredPlatformCommands | null>;
+export declare const runPlatformCommand: (options: {
+    argv: string[];
+    cwd: string;
+    loadConfig?: ConfigLoader;
+}) => Promise<boolean>;
+export {};
+//# sourceMappingURL=platform-commands.d.ts.map

package/dist/platform-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-commands.d.ts","sourceRoot":"","sources":["../src/platform-commands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,KAAK,YAAY,GAAG,OAAO,SAAS,CAAC;AAErC,KAAK,0BAA0B,GAAG;IAChC,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsEF,eAAO,MAAM,wBAAwB,GAAU,SAAS;IACtD,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B,KAAG,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAgC5C,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B,KAAG,OAAO,CAAC,OAAO,CA4BlB,CAAC"}

package/dist/platform-commands.js

@@ -0,0 +1,84 @@
+import { ConfigNotFoundError, getConfig } from '@react-native-harness/config';
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const getModuleCommands = (importedModule, modulePath) => {
+    const moduleValue = isRecord(importedModule)
+        ? importedModule
+        : {};
+    const defaultExport = isRecord(moduleValue.default)
+        ? moduleValue.default
+        : undefined;
+    const commandsValue = moduleValue.commands ?? defaultExport?.commands;
+    if (!Array.isArray(commandsValue)) {
+        throw new Error(`Invalid platform CLI module '${modulePath}': expected a commands array.`);
+    }
+    return commandsValue.map((command, index) => {
+        if (!isRecord(command) || typeof command.name !== 'string') {
+            throw new Error(`Invalid platform CLI module '${modulePath}': command #${index + 1} is missing a valid name.`);
+        }
+        if (typeof command.run !== 'function') {
+            throw new Error(`Invalid platform CLI module '${modulePath}': command '${command.name}' is missing a run handler.`);
+        }
+        if (command.aliases !== undefined &&
+            (!Array.isArray(command.aliases) ||
+                command.aliases.some((alias) => typeof alias !== 'string'))) {
+            throw new Error(`Invalid platform CLI module '${modulePath}': command '${command.name}' has invalid aliases.`);
+        }
+        return command;
+    });
+};
+const registerCommandNames = (seenNames, modulePath, command) => {
+    const names = [command.name, ...(command.aliases ?? [])];
+    for (const name of names) {
+        const existingSource = seenNames.get(name);
+        if (existingSource !== undefined) {
+            throw new Error(`Duplicate platform CLI command '${name}' in '${modulePath}' and '${existingSource}'.`);
+        }
+        seenNames.set(name, modulePath);
+    }
+};
+export const discoverPlatformCommands = async (options) => {
+    const loadConfig = options.loadConfig ?? getConfig;
+    try {
+        const { config, projectRoot } = await loadConfig(options.cwd);
+        const modulePaths = [...new Set(config.runners.map((runner) => runner.cli))].filter((modulePath) => typeof modulePath === 'string');
+        const commands = [];
+        const seenNames = new Map();
+        for (const modulePath of modulePaths) {
+            const importedModule = await import(modulePath);
+            const moduleCommands = getModuleCommands(importedModule, modulePath);
+            for (const command of moduleCommands) {
+                registerCommandNames(seenNames, modulePath, command);
+                commands.push(command);
+            }
+        }
+        return {
+            commands,
+            projectRoot,
+        };
+    }
+    catch (error) {
+        if (error instanceof ConfigNotFoundError) {
+            return null;
+        }
+        throw error;
+    }
+};
+export const runPlatformCommand = async (options) => {
+    const commandName = options.argv[0];
+    if (typeof commandName !== 'string' || commandName.length === 0) {
+        return false;
+    }
+    const discoveredCommands = await discoverPlatformCommands(options);
+    if (discoveredCommands === null) {
+        return false;
+    }
+    const command = discoveredCommands.commands.find((entry) => entry.name === commandName || entry.aliases?.includes(commandName) === true);
+    if (command === undefined) {
+        return false;
+    }
+    await command.run(options.argv.slice(1), {
+        cwd: options.cwd,
+        projectRoot: discoveredCommands.projectRoot,
+    });
+    return true;
+};

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,10 @@
+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>;
+//# 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,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"}