@react-native-harness/platform-android 1.0.0-alpha.18

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,99 @@
+![harness-banner](https://react-native-harness.dev/harness-banner.jpg)
+
+[![mit licence][license-badge]][license]
+[![npm downloads][npm-downloads-badge]][npm-downloads]
+[![Chat][chat-badge]][chat]
+[![PRs Welcome][prs-welcome-badge]][prs-welcome]
+
+Android platform for React Native Harness - enables testing on Android emulators and physical devices.
+
+## Installation
+
+```bash
+npm install @react-native-harness/platform-android
+# or
+pnpm add @react-native-harness/platform-android
+# or
+yarn add @react-native-harness/platform-android
+```
+
+## Usage
+
+Import the Android platform functions in your `rn-harness.config.mjs`:
+
+```javascript
+import {
+  androidPlatform,
+  androidEmulator,
+  physicalAndroidDevice,
+} from '@react-native-harness/platform-android';
+
+const config = {
+  runners: [
+    androidPlatform({
+      name: 'android',
+      device: androidEmulator('Pixel_8_API_35'),
+      bundleId: 'com.your.app',
+    }),
+    androidPlatform({
+      name: 'physical-device',
+      device: physicalAndroidDevice('Motorola', 'Moto G72'),
+      bundleId: 'com.your.app',
+    }),
+  ],
+  // ... other config
+};
+
+export default config;
+```
+
+## API
+
+### `androidPlatform(config)`
+
+Creates an Android platform runner configuration.
+
+**Parameters:**
+
+- `config.name` - Unique name for the runner
+- `config.device` - Android device configuration (emulator or physical)
+- `config.bundleId` - Android application bundle ID
+
+### `androidEmulator(deviceName)`
+
+Creates an Android emulator device configuration.
+
+**Parameters:**
+
+- `deviceName` - Name of the Android emulator (e.g., 'Pixel_8_API_35')
+
+### `physicalAndroidDevice(manufacturer, model)`
+
+Creates a physical Android device configuration.
+
+**Parameters:**
+
+- `manufacturer` - Device manufacturer (e.g., 'Motorola')
+- `model` - Device model (e.g., 'Moto G72')
+
+## Requirements
+
+- Android SDK installed
+- Android emulator or physical device connected
+- React Native project configured for Android
+
+## Made with ❤️ at Callstack
+
+`react-native-harness` is an open source project and will always remain free to use. If you think it's cool, please star it 🌟. [Callstack][callstack-readme-with-love] is a group of React and React Native geeks, contact us at [hello@callstack.com](mailto:hello@callstack.com) if you need any help with these or just want to say hi!
+
+Like the project? ⚛️ [Join the team](https://callstack.com/careers/?utm_campaign=Senior_RN&utm_source=github&utm_medium=readme) who does amazing stuff for clients and drives React Native Open Source! 🔥
+
+[callstack-readme-with-love]: https://callstack.com/?utm_source=github.com&utm_medium=referral&utm_campaign=react-native-harness&utm_term=readme-with-love
+[license-badge]: https://img.shields.io/npm/l/react-native-harness?style=for-the-badge
+[license]: https://github.com/callstackincubator/react-native-harness/blob/main/LICENSE
+[npm-downloads-badge]: https://img.shields.io/npm/dm/react-native-harness?style=for-the-badge
+[npm-downloads]: https://www.npmjs.com/package/react-native-harness
+[prs-welcome-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=for-the-badge
+[prs-welcome]: ./CONTRIBUTING.md
+[chat-badge]: https://img.shields.io/discord/426714625279524876.svg?style=for-the-badge
+[chat]: https://discord.gg/xgGt7KAjxv

package/dist/adb-id.d.ts

@@ -0,0 +1,4 @@
+import { AndroidDevice } from './config.js';
+export declare const isAdbIdEmulator: (adbId: string) => boolean;
+export declare const getAdbId: (device: AndroidDevice) => Promise<string | null>;
+//# sourceMappingURL=adb-id.d.ts.map

package/dist/adb-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adb-id.d.ts","sourceRoot":"","sources":["../src/adb-id.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,aAAa,EACd,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,KAAG,OAE/C,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,QAAQ,aAAa,KACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAsBvB,CAAC"}

package/dist/adb-id.js

@@ -0,0 +1,24 @@
+import * as adb from './adb.js';
+import { isAndroidDeviceEmulator, isAndroidDevicePhysical, } from './config.js';
+export const isAdbIdEmulator = (adbId) => {
+    return adbId.startsWith('emulator-');
+};
+export const getAdbId = async (device) => {
+    const adbIds = await adb.getDeviceIds();
+    for (const adbId of adbIds) {
+        if (isAndroidDeviceEmulator(device)) {
+            const emulatorName = await adb.getEmulatorName(adbId);
+            if (emulatorName === device.name) {
+                return adbId;
+            }
+        }
+        else if (isAndroidDevicePhysical(device)) {
+            const deviceInfo = await adb.getDeviceInfo(adbId);
+            if (deviceInfo?.manufacturer === device.manufacturer &&
+                deviceInfo?.model === device.model) {
+                return adbId;
+            }
+        }
+    }
+    return null;
+};

package/dist/adb.d.ts

@@ -0,0 +1,15 @@
+export declare const isAppInstalled: (adbId: string, bundleId: string) => Promise<boolean>;
+export declare const reversePort: (adbId: string, port: number) => Promise<void>;
+export declare const stopApp: (adbId: string, bundleId: string) => Promise<void>;
+export declare const startApp: (adbId: string, bundleId: string, activityName: string) => Promise<void>;
+export declare const getDeviceIds: () => Promise<string[]>;
+export declare const getEmulatorName: (adbId: string) => Promise<string | null>;
+export declare const getShellProperty: (adbId: string, property: string) => Promise<string | null>;
+export type DeviceInfo = {
+    manufacturer: string | null;
+    model: string | null;
+};
+export declare const getDeviceInfo: (adbId: string) => Promise<DeviceInfo | null>;
+export declare const isBootCompleted: (adbId: string) => Promise<boolean>;
+export declare const stopEmulator: (adbId: string) => Promise<void>;
+//# sourceMappingURL=adb.d.ts.map

package/dist/adb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adb.d.ts","sourceRoot":"","sources":["../src/adb.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,GACzB,OAAO,MAAM,EACb,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAWjB,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,OAAO,MAAM,EACb,MAAM,MAAM,KACX,OAAO,CAAC,IAAI,CAEd,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,OAAO,MAAM,EACb,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAEd,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,OAAO,MAAM,EACb,UAAU,MAAM,EAChB,cAAc,MAAM,KACnB,OAAO,CAAC,IAAI,CAUd,CAAC;AAEF,eAAO,MAAM,YAAY,QAAa,OAAO,CAAC,MAAM,EAAE,CAOrD,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,OAAO,MAAM,KACZ,OAAO,CAAC,MAAM,GAAG,IAAI,CAGvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,EACb,UAAU,MAAM,KACf,OAAO,CAAC,MAAM,GAAG,IAAI,CASvB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,OAAO,MAAM,KACZ,OAAO,CAAC,UAAU,GAAG,IAAI,CAI3B,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,OAAO,MAAM,KAAG,OAAO,CAAC,OAAO,CAGpE,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,OAAO,MAAM,KAAG,OAAO,CAAC,IAAI,CAE9D,CAAC"}

package/dist/adb.js

@@ -0,0 +1,64 @@
+import { spawn } from '@react-native-harness/tools';
+export const isAppInstalled = async (adbId, bundleId) => {
+    const { stdout } = await spawn('adb', [
+        '-s',
+        adbId,
+        'shell',
+        'pm',
+        'list',
+        'packages',
+        bundleId,
+    ]);
+    return stdout.trim() !== '';
+};
+export const reversePort = async (adbId, port) => {
+    await spawn('adb', ['-s', adbId, 'reverse', `tcp:${port}`, `tcp:${port}`]);
+};
+export const stopApp = async (adbId, bundleId) => {
+    await spawn('adb', ['-s', adbId, 'shell', 'am', 'force-stop', bundleId]);
+};
+export const startApp = async (adbId, bundleId, activityName) => {
+    await spawn('adb', [
+        '-s',
+        adbId,
+        'shell',
+        'am',
+        'start',
+        '-n',
+        `${bundleId}/${activityName}`,
+    ]);
+};
+export const getDeviceIds = async () => {
+    const { stdout } = await spawn('adb', ['devices']);
+    return stdout
+        .split('\n')
+        .slice(1) // Skip header
+        .filter((line) => line.trim() !== '')
+        .map((line) => line.split('\t')[0]);
+};
+export const getEmulatorName = async (adbId) => {
+    const { stdout } = await spawn('adb', ['-s', adbId, 'emu', 'avd', 'name']);
+    return stdout.split('\n')[0].trim() || null;
+};
+export const getShellProperty = async (adbId, property) => {
+    const { stdout } = await spawn('adb', [
+        '-s',
+        adbId,
+        'shell',
+        'getprop',
+        property,
+    ]);
+    return stdout.trim() || null;
+};
+export const getDeviceInfo = async (adbId) => {
+    const manufacturer = await getShellProperty(adbId, 'ro.product.manufacturer');
+    const model = await getShellProperty(adbId, 'ro.product.model');
+    return { manufacturer, model };
+};
+export const isBootCompleted = async (adbId) => {
+    const bootCompleted = await getShellProperty(adbId, 'sys.boot_completed');
+    return bootCompleted === '1';
+};
+export const stopEmulator = async (adbId) => {
+    await spawn('adb', ['-s', adbId, 'emu', 'kill']);
+};

package/dist/assertions.d.ts

@@ -0,0 +1,5 @@
+import { Config, NativeTestRunnerConfig } from './types.js';
+export declare function assertNativeRunner(config: Config): asserts config is Config & {
+    runner: NativeTestRunnerConfig;
+};
+//# sourceMappingURL=assertions.d.ts.map

package/dist/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAE5D,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,IAAI,MAAM,GAAG;IAAE,MAAM,EAAE,sBAAsB,CAAA;CAAE,CAO/D"}

package/dist/assertions.js

@@ -0,0 +1,6 @@
+export function assertNativeRunner(config) {
+    if (config.runner.platform !== 'ios' &&
+        config.runner.platform !== 'android') {
+        throw new Error('Runner is not a native runner');
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+export declare const AndroidEmulatorSchema: z.ZodObject<{
+    type: z.ZodLiteral<"emulator">;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "emulator";
+    name: string;
+}, {
+    type: "emulator";
+    name: string;
+}>;
+export declare const PhysicalAndroidDeviceSchema: z.ZodObject<{
+    type: z.ZodLiteral<"physical">;
+    manufacturer: z.ZodString;
+    model: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "physical";
+    manufacturer: string;
+    model: string;
+}, {
+    type: "physical";
+    manufacturer: string;
+    model: string;
+}>;
+export declare const AndroidDeviceSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"emulator">;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "emulator";
+    name: string;
+}, {
+    type: "emulator";
+    name: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"physical">;
+    manufacturer: z.ZodString;
+    model: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "physical";
+    manufacturer: string;
+    model: string;
+}, {
+    type: "physical";
+    manufacturer: string;
+    model: string;
+}>]>;
+export declare const AndroidPlatformConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    device: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"emulator">;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "emulator";
+        name: string;
+    }, {
+        type: "emulator";
+        name: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"physical">;
+        manufacturer: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "physical";
+        manufacturer: string;
+        model: string;
+    }, {
+        type: "physical";
+        manufacturer: string;
+        model: string;
+    }>]>;
+    bundleId: z.ZodString;
+    activityName: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    device: {
+        type: "emulator";
+        name: string;
+    } | {
+        type: "physical";
+        manufacturer: string;
+        model: string;
+    };
+    bundleId: string;
+    activityName: string;
+}, {
+    name: string;
+    device: {
+        type: "emulator";
+        name: string;
+    } | {
+        type: "physical";
+        manufacturer: string;
+        model: string;
+    };
+    bundleId: string;
+    activityName?: string | undefined;
+}>;
+export type AndroidEmulator = z.infer<typeof AndroidEmulatorSchema>;
+export type PhysicalAndroidDevice = z.infer<typeof PhysicalAndroidDeviceSchema>;
+export type AndroidDevice = z.infer<typeof AndroidDeviceSchema>;
+export type AndroidPlatformConfig = z.infer<typeof AndroidPlatformConfigSchema>;
+export declare const isAndroidDeviceEmulator: (device: AndroidDevice) => device is AndroidEmulator;
+export declare const isAndroidDevicePhysical: (device: AndroidDevice) => device is PhysicalAndroidDevice;
+export declare function assertAndroidDeviceEmulator(device: AndroidDevice): asserts device is AndroidEmulator;
+export declare function assertAndroidDevicePhysical(device: AndroidDevice): asserts device is PhysicalAndroidDevice;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAItC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;IAG9B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQtC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,eAEZ,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,qBAEZ,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,eAAe,CAInC;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,qBAAqB,CAIzC"}

package/dist/config.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export const AndroidEmulatorSchema = z.object({
+    type: z.literal('emulator'),
+    name: z.string().min(1, 'Name is required'),
+});
+export const PhysicalAndroidDeviceSchema = z.object({
+    type: z.literal('physical'),
+    manufacturer: z.string().min(1, 'Manufacturer is required'),
+    model: z.string().min(1, 'Model is required'),
+});
+export const AndroidDeviceSchema = z.discriminatedUnion('type', [
+    AndroidEmulatorSchema,
+    PhysicalAndroidDeviceSchema,
+]);
+export const AndroidPlatformConfigSchema = z.object({
+    name: z.string().min(1, 'Name is required'),
+    device: AndroidDeviceSchema,
+    bundleId: z.string().min(1, 'Bundle ID is required'),
+    activityName: z
+        .string()
+        .min(1, 'Activity name is required')
+        .default('.MainActivity'),
+});
+export const isAndroidDeviceEmulator = (device) => {
+    return device.type === 'emulator';
+};
+export const isAndroidDevicePhysical = (device) => {
+    return device.type === 'physical';
+};
+export function assertAndroidDeviceEmulator(device) {
+    if (!isAndroidDeviceEmulator(device)) {
+        throw new Error('Device is not an emulator');
+    }
+}
+export function assertAndroidDevicePhysical(device) {
+    if (!isAndroidDevicePhysical(device)) {
+        throw new Error('Device is not a physical device');
+    }
+}

package/dist/emulator.d.ts

@@ -0,0 +1,6 @@
+export type AndroidEmulator = {
+    adbId: string;
+    stop: () => Promise<void>;
+};
+export declare const runEmulator: (avdName: string) => Promise<AndroidEmulator>;
+//# sourceMappingURL=emulator.d.ts.map

package/dist/emulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emulator.d.ts","sourceRoot":"","sources":["../src/emulator.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,SAAS,MAAM,KACd,OAAO,CAAC,eAAe,CA8BzB,CAAC"}

package/dist/emulator.js

@@ -0,0 +1,27 @@
+import { spawn } from '@react-native-harness/tools';
+import * as adb from './adb.js';
+export const runEmulator = async (avdName) => {
+    const process = spawn('emulator', ['-avd', avdName]);
+    await process.nodeChildProcess;
+    const adbId = await adb.getEmulatorName(avdName);
+    if (!adbId) {
+        throw new Error('Emulator not found');
+    }
+    // Poll for emulator status until it's fully running
+    const checkStatus = async () => {
+        const status = await adb.isBootCompleted(adbId);
+        if (!status) {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            await checkStatus();
+        }
+    };
+    // Start checking status after a brief delay to allow emulator to start
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+    await checkStatus();
+    return {
+        adbId,
+        stop: async () => {
+            await adb.stopEmulator(adbId);
+        },
+    };
+};

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class ConfigValidationError extends Error {
+    readonly filePath: string;
+    readonly validationErrors: string[];
+    constructor(filePath: string, validationErrors: string[]);
+}
+export declare class ConfigNotFoundError extends Error {
+    readonly searchPath: string;
+    constructor(searchPath: string);
+}
+export declare class ConfigLoadError extends Error {
+    readonly filePath: string;
+    readonly cause?: Error;
+    constructor(filePath: string, cause?: Error);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,qBAAsB,SAAQ,KAAK;aAExB,QAAQ,EAAE,MAAM;aAChB,gBAAgB,EAAE,MAAM,EAAE;gBAD1B,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EAAE;CAKjD;AAED,qBAAa,mBAAoB,SAAQ,KAAK;aACd,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAIjD;AAED,qBAAa,eAAgB,SAAQ,KAAK;aAGV,QAAQ,EAAE,MAAM;IAF5C,SAAyB,KAAK,CAAC,EAAE,KAAK,CAAC;gBAEX,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAK9D"}

package/dist/errors.js

@@ -0,0 +1,28 @@
+export class ConfigValidationError extends Error {
+    filePath;
+    validationErrors;
+    constructor(filePath, validationErrors) {
+        super(`Invalid configuration in ${filePath}`);
+        this.filePath = filePath;
+        this.validationErrors = validationErrors;
+        this.name = 'ConfigValidationError';
+    }
+}
+export class ConfigNotFoundError extends Error {
+    searchPath;
+    constructor(searchPath) {
+        super(`Config file not found in ${searchPath} or any parent directories`);
+        this.searchPath = searchPath;
+        this.name = 'ConfigNotFoundError';
+    }
+}
+export class ConfigLoadError extends Error {
+    filePath;
+    cause;
+    constructor(filePath, cause) {
+        super(`Failed to load config file ${filePath}`);
+        this.filePath = filePath;
+        this.name = 'ConfigLoadError';
+        this.cause = cause;
+    }
+}

package/dist/factory.d.ts

@@ -0,0 +1,6 @@
+import { HarnessPlatform } from '@react-native-harness/platforms';
+import { type AndroidEmulator, type AndroidPlatformConfig, type PhysicalAndroidDevice } from './config.js';
+export declare const androidEmulator: (name: string) => AndroidEmulator;
+export declare const physicalAndroidDevice: (manufacturer: string, model: string) => PhysicalAndroidDevice;
+export declare const androidPlatform: (config: AndroidPlatformConfig) => HarnessPlatform;
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EAChB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAKrB,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,eAG7C,CAAC;AAEH,eAAO,MAAM,qBAAqB,GAChC,cAAc,MAAM,EACpB,OAAO,MAAM,KACZ,qBAID,CAAC;AAEH,eAAO,MAAM,eAAe,GAC1B,QAAQ,qBAAqB,KAC5B,eAiDD,CAAC"}

package/dist/factory.js

@@ -0,0 +1,48 @@
+import { DeviceNotFoundError, AppNotInstalledError, } from '@react-native-harness/platforms';
+import { AndroidPlatformConfigSchema, } from './config.js';
+import { getAdbId } from './adb-id.js';
+import * as adb from './adb.js';
+import { getDeviceName } from './utils.js';
+export const androidEmulator = (name) => ({
+    type: 'emulator',
+    name,
+});
+export const physicalAndroidDevice = (manufacturer, model) => ({
+    type: 'physical',
+    manufacturer: manufacturer.toLowerCase(),
+    model: model.toLowerCase(),
+});
+export const androidPlatform = (config) => ({
+    name: config.name,
+    getInstance: async () => {
+        const parsedConfig = AndroidPlatformConfigSchema.parse(config);
+        const adbId = await getAdbId(parsedConfig.device);
+        if (!adbId) {
+            throw new DeviceNotFoundError(getDeviceName(parsedConfig.device));
+        }
+        const isInstalled = await adb.isAppInstalled(adbId, parsedConfig.bundleId);
+        if (!isInstalled) {
+            throw new AppNotInstalledError(parsedConfig.bundleId, getDeviceName(parsedConfig.device));
+        }
+        await Promise.all([
+            adb.reversePort(adbId, 8081),
+            adb.reversePort(adbId, 8080),
+            adb.reversePort(adbId, 3001),
+        ]);
+        return {
+            startApp: async () => {
+                await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName);
+            },
+            restartApp: async () => {
+                await adb.stopApp(adbId, parsedConfig.bundleId);
+                await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName);
+            },
+            stopApp: async () => {
+                await adb.stopApp(adbId, parsedConfig.bundleId);
+            },
+            dispose: async () => {
+                await adb.stopApp(adbId, parsedConfig.bundleId);
+            },
+        };
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { androidEmulator, physicalAndroidDevice, androidPlatform, } from './factory.js';
+export type { AndroidPlatformConfig } from './config.js';
+//# 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":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { androidEmulator, physicalAndroidDevice, androidPlatform, } from './factory.js';

package/dist/reader.d.ts

@@ -0,0 +1,6 @@
+import { Config } from './types.js';
+export declare const getConfig: (dir: string) => Promise<{
+    config: Config;
+    projectRoot: string;
+}>;
+//# sourceMappingURL=reader.d.ts.map

package/dist/reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../src/reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,YAAY,CAAC;AAsElD,eAAO,MAAM,SAAS,GACpB,KAAK,MAAM,KACV,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAUjD,CAAC"}

package/dist/reader.js

@@ -0,0 +1,57 @@
+import { ConfigSchema } from './types.js';
+import { ConfigValidationError, ConfigNotFoundError, ConfigLoadError, } from './errors.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import { ZodError } from 'zod';
+const extensions = ['.js', '.mjs', '.cjs', '.json'];
+const importUp = async (dir, name) => {
+    const filePath = path.join(dir, name);
+    for (const ext of extensions) {
+        const filePathWithExt = `${filePath}${ext}`;
+        if (fs.existsSync(filePathWithExt)) {
+            let rawConfig;
+            try {
+                if (ext === '.mjs') {
+                    rawConfig = await import(filePathWithExt).then((module) => module.default);
+                }
+                else {
+                    const require = createRequire(import.meta.url);
+                    rawConfig = require(filePathWithExt);
+                }
+            }
+            catch (error) {
+                throw new ConfigLoadError(filePathWithExt, error instanceof Error ? error : undefined);
+            }
+            try {
+                const config = ConfigSchema.parse(rawConfig);
+                return { config, filePathWithExt, configDir: dir };
+            }
+            catch (error) {
+                if (error instanceof ZodError) {
+                    const validationErrors = error.errors.map((err) => {
+                        const path = err.path.length > 0 ? ` at "${err.path.join('.')}"` : '';
+                        return `${err.message}${path}`;
+                    });
+                    throw new ConfigValidationError(filePathWithExt, validationErrors);
+                }
+                throw error;
+            }
+        }
+    }
+    const parentDir = path.dirname(dir);
+    if (parentDir === dir) {
+        throw new ConfigNotFoundError(dir);
+    }
+    return importUp(parentDir, name);
+};
+export const getConfig = async (dir) => {
+    const { config, configDir } = await importUp(dir, 'rn-harness.config');
+    return {
+        config: {
+            ...config,
+            reporter: config.reporter,
+        },
+        projectRoot: configDir,
+    };
+};