@react-native-harness/jest 1.1.0-rc.2 → 1.1.0-rc.4

package/dist/jest-options.d.ts

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

package/dist/jest-options.d.ts.map

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

package/dist/jest-options.js

@@ -0,0 +1 @@
+export {};

package/dist/logs.d.ts

@@ -3,7 +3,11 @@ import { HarnessError } from '@react-native-harness/tools';
 export declare const log: (message: string) => void;
 export declare const logTestRunHeader: (runner: HarnessPlatform) => void;
 export declare const logTestEnvironmentReady: (runner: HarnessPlatform) => void;
+export declare const logRunnerWaitingInQueue: (runner: HarnessPlatform) => void;
+export declare const logRunnerStillWaitingInQueue: (runner: HarnessPlatform) => void;
+export declare const logRunnerStarting: (runner: HarnessPlatform) => void;
 export declare const logMetroPrewarmCompleted: (runner: HarnessPlatform) => void;
 export declare const logMetroCacheReused: (runner: HarnessPlatform) => void;
+export declare const logMetroPortFallback: (initialPort: number, selectedPort: number) => void;
 export declare const getErrorMessage: (error: HarnessError) => string;
 //# sourceMappingURL=logs.d.ts.map

package/dist/logs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../src/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAY3D,eAAO,MAAM,GAAG,GAAI,SAAS,MAAM,KAAG,IAErC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,eAAe,KAAG,IAI1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,eAAe,KAAG,IAIlE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,eAAe,KAAG,IAE7D,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,YAAY,KAAG,MAErD,CAAC"}
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../src/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAY3D,eAAO,MAAM,GAAG,GAAI,SAAS,MAAM,KAAG,IAErC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,eAAe,KAAG,IAI1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,QAAQ,eAAe,KAAG,IAEtE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,eAAe,KAAG,IAE3D,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,eAAe,KAAG,IAElE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,eAAe,KAAG,IAE7D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,aAAa,MAAM,EACnB,cAAc,MAAM,KACnB,IAMF,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,YAAY,KAAG,MAErD,CAAC"}

package/dist/logs.js

@@ -15,12 +15,24 @@ export const logTestRunHeader = (runner) => {
 export const logTestEnvironmentReady = (runner) => {
     log(`${TAG} Runner ${chalk.bold(runner.name)} ready\n`);
 };
+export const logRunnerWaitingInQueue = (runner) => {
+    log(`${TAG} Runner ${chalk.bold(runner.name)} is busy, waiting in queue\n`);
+};
+export const logRunnerStillWaitingInQueue = (runner) => {
+    log(`${TAG} Still waiting in queue for ${chalk.bold(runner.name)} runner\n`);
+};
+export const logRunnerStarting = (runner) => {
+    log(`${TAG} Runner ${chalk.bold(runner.name)} is starting\n`);
+};
 export const logMetroPrewarmCompleted = (runner) => {
     log(`${TAG} Metro pre-warm for ${chalk.bold(runner.name)} completed\n`);
 };
 export const logMetroCacheReused = (runner) => {
     log(`${TAG} Reusing Metro cache for ${chalk.bold(runner.name)}\n`);
 };
+export const logMetroPortFallback = (initialPort, selectedPort) => {
+    log(`${TAG} Harness could not use Metro port ${chalk.bold(String(initialPort))} and is using ${chalk.bold(String(selectedPort))} instead.\n`);
+};
 export const getErrorMessage = (error) => {
     return `${ERROR_TAG} ${error.message}\n`;
 };

package/dist/metro-port.d.ts

@@ -0,0 +1,16 @@
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+import type { HarnessPlatform } from '@react-native-harness/platforms';
+import type { ResourceLease, ResourceLockManager } from './resource-lock.js';
+export declare const METRO_PORT_SCAN_ATTEMPTS = 10;
+export declare const resolveHarnessMetroPort: (options: {
+    config: HarnessConfig;
+    platform: HarnessPlatform;
+    resourceLockManager: ResourceLockManager;
+    signal: AbortSignal;
+}) => Promise<{
+    config: HarnessConfig;
+    metroPortLease: ResourceLease | null;
+    initialMetroPort: number;
+    didFallback: boolean;
+}>;
+//# sourceMappingURL=metro-port.d.ts.map

package/dist/metro-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metro-port.d.ts","sourceRoot":"","sources":["../src/metro-port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE7E,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAU3C,eAAO,MAAM,uBAAuB,GAAU,SAAS;IACrD,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,EAAE,eAAe,CAAC;IAC1B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,MAAM,EAAE,WAAW,CAAC;CACrB,KAAG,OAAO,CAAC;IACV,MAAM,EAAE,aAAa,CAAC;IACtB,cAAc,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,OAAO,CAAC;CACtB,CAiDA,CAAC"}

package/dist/metro-port.js

@@ -0,0 +1,48 @@
+import { isPortAvailable } from '@react-native-harness/bundler-metro';
+import { MetroPortRangeExhaustedError } from './errors.js';
+export const METRO_PORT_SCAN_ATTEMPTS = 10;
+const getPortLockKey = (host, port) => {
+    return `metro-port:${host?.trim() || '*'}:${port}`;
+};
+const isIosPhysicalRunner = (platform) => {
+    return platform.platformId === 'ios' && platform.name.includes('device');
+};
+export const resolveHarnessMetroPort = async (options) => {
+    const { config, platform, resourceLockManager, signal } = options;
+    const initialMetroPort = config.metroPort;
+    const host = config.host?.trim();
+    if (isIosPhysicalRunner(platform)) {
+        return {
+            config,
+            metroPortLease: null,
+            initialMetroPort,
+            didFallback: false,
+        };
+    }
+    for (let attempt = 0; attempt < METRO_PORT_SCAN_ATTEMPTS; attempt += 1) {
+        const candidatePort = initialMetroPort + attempt;
+        const metroPortLease = await resourceLockManager.acquire(getPortLockKey(host, candidatePort), { signal });
+        try {
+            if (!(await isPortAvailable(candidatePort, host))) {
+                await metroPortLease.release();
+                continue;
+            }
+            return {
+                config: candidatePort === initialMetroPort
+                    ? config
+                    : {
+                        ...config,
+                        metroPort: candidatePort,
+                    },
+                metroPortLease,
+                initialMetroPort,
+                didFallback: candidatePort !== initialMetroPort,
+            };
+        }
+        catch (error) {
+            await metroPortLease.release();
+            throw error;
+        }
+    }
+    throw new MetroPortRangeExhaustedError(initialMetroPort, METRO_PORT_SCAN_ATTEMPTS);
+};

package/dist/resource-lock.d.ts

@@ -0,0 +1,25 @@
+import { type HarnessLogger } from '@react-native-harness/tools';
+export type ResourceLockAcquireOptions = {
+    signal?: AbortSignal;
+    onWait?: () => void;
+    onStillWaiting?: (elapsedMs: number) => void;
+};
+export type ResourceLease = {
+    release: () => Promise<void>;
+};
+export type ResourceLockManager = {
+    acquire: (key: string, options?: ResourceLockAcquireOptions) => Promise<ResourceLease>;
+};
+type ResourceLockManagerOptions = {
+    rootDir?: string;
+    pollIntervalMs?: number;
+    heartbeatIntervalMs?: number;
+    staleLockTimeoutMs?: number;
+    pid?: number;
+    logger?: HarnessLogger;
+    isProcessActive?: (pid: number) => boolean;
+};
+export declare const hashResourceLockKey: (key: string) => string;
+export declare const createResourceLockManager: (options?: ResourceLockManagerOptions) => ResourceLockManager;
+export {};
+//# sourceMappingURL=resource-lock.d.ts.map

package/dist/resource-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-lock.d.ts","sourceRoot":"","sources":["../src/resource-lock.ts"],"names":[],"mappings":"AAIA,OAAO,EAAU,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAiBzE,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,CACP,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,0BAA0B,KACjC,OAAO,CAAC,aAAa,CAAC,CAAC;CAC7B,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C,CAAC;AAgBF,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,KAAG,MAEjD,CAAC;AAmPF,eAAO,MAAM,yBAAyB,GACpC,UAAS,0BAA+B,KACvC,mBAkKF,CAAC"}

package/dist/resource-lock.js

@@ -0,0 +1,299 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { logger } from '@react-native-harness/tools';
+const resourceLockLogger = logger.child('resource-lock');
+const DEFAULT_ROOT_DIR = path.join(os.tmpdir(), 'react-native-harness-locks');
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 2000;
+const DEFAULT_STALE_LOCK_TIMEOUT_MS = 15000;
+const wait = async (ms) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+};
+const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
+export const hashResourceLockKey = (key) => {
+    return crypto.createHash('sha256').update(key).digest('hex');
+};
+const getPathsForKey = (rootDir, key) => {
+    const keyDir = path.join(rootDir, hashResourceLockKey(key));
+    return {
+        rootDir,
+        keyDir,
+        queueDir: path.join(keyDir, 'queue'),
+        ownerFilePath: path.join(keyDir, 'owner.json'),
+    };
+};
+const createTicketId = (createdAt, pid) => {
+    return `${createdAt
+        .toString()
+        .padStart(16, '0')}-${pid}-${crypto.randomUUID()}`;
+};
+const isMissingFileError = (error) => {
+    return (error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        error.code === 'ENOENT');
+};
+const isExclusiveCreateError = (error) => {
+    return (error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        error.code === 'EEXIST');
+};
+const ensureLockDirectories = async (paths) => {
+    await fs.mkdir(paths.queueDir, { recursive: true });
+};
+const readJsonFile = async (filePath) => {
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        throw error;
+    }
+};
+const writeJsonFileAtomic = async (filePath, value) => {
+    const tempPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+        await fs.writeFile(tempPath, JSON.stringify(value), 'utf8');
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await removeFileIfPresent(tempPath);
+        throw error;
+    }
+};
+const removeFileIfPresent = async (filePath) => {
+    try {
+        await fs.rm(filePath, { force: true });
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            throw error;
+        }
+    }
+};
+const isPidActive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !(error instanceof Error &&
+            'code' in error &&
+            typeof error.code === 'string' &&
+            error.code === 'ESRCH');
+    }
+};
+const isMetadataStale = (metadata, now, staleLockTimeoutMs, isProcessActive) => {
+    if (!isProcessActive(metadata.pid)) {
+        return true;
+    }
+    return now - metadata.heartbeatAt > staleLockTimeoutMs;
+};
+const isQueuedTicketStale = (metadata, isProcessActive) => {
+    return !isProcessActive(metadata.pid);
+};
+const waitForPollInterval = (ms, signal) => {
+    if (!signal) {
+        return wait(ms);
+    }
+    if (signal.aborted) {
+        return Promise.reject(signal.reason ?? createAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
+            reject(signal.reason ?? createAbortError());
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+};
+const readQueueTickets = async (queueDir) => {
+    const ticketEntries = await fs.readdir(queueDir, { withFileTypes: true });
+    const tickets = await Promise.all(ticketEntries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+        .map(async (entry) => ({
+        name: entry.name,
+        metadata: await readJsonFile(path.join(queueDir, entry.name)),
+    })));
+    return tickets
+        .filter((entry) => entry.metadata !== null)
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .map((entry) => entry.metadata);
+};
+const cleanupQueue = async (options) => {
+    const { paths, currentTicketId, logger, isProcessActive } = options;
+    const tickets = await readQueueTickets(paths.queueDir);
+    const activeTickets = [];
+    for (const ticket of tickets) {
+        const isCurrentTicket = ticket.ticketId === currentTicketId;
+        const isStale = !isCurrentTicket && isQueuedTicketStale(ticket, isProcessActive);
+        if (isStale) {
+            logger.debug('removing stale queued ticket %s for key %s', ticket.ticketId, ticket.key);
+            await removeFileIfPresent(path.join(paths.queueDir, `${ticket.ticketId}.json`));
+            continue;
+        }
+        activeTickets.push(ticket);
+    }
+    return activeTickets;
+};
+const maybeClearStaleOwner = async (options) => {
+    const { ownerFilePath, staleLockTimeoutMs, now, logger, isProcessActive } = options;
+    const owner = await readJsonFile(ownerFilePath);
+    if (!owner) {
+        return null;
+    }
+    if (!isMetadataStale(owner, now, staleLockTimeoutMs, isProcessActive)) {
+        return owner;
+    }
+    logger.debug('removing stale owner ticket %s for key %s', owner.ticketId, owner.key);
+    await removeFileIfPresent(ownerFilePath);
+    return null;
+};
+const claimOwnership = async (ownerFilePath, metadata) => {
+    try {
+        await fs.writeFile(ownerFilePath, JSON.stringify(metadata), {
+            encoding: 'utf8',
+            flag: 'wx',
+        });
+        return true;
+    }
+    catch (error) {
+        if (isExclusiveCreateError(error)) {
+            return false;
+        }
+        throw error;
+    }
+};
+export const createResourceLockManager = (options = {}) => {
+    const rootDir = options.rootDir ?? DEFAULT_ROOT_DIR;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    const staleLockTimeoutMs = options.staleLockTimeoutMs ?? DEFAULT_STALE_LOCK_TIMEOUT_MS;
+    const pid = options.pid ?? process.pid;
+    const scopedLogger = options.logger ?? resourceLockLogger;
+    const isProcessActive = options.isProcessActive ?? isPidActive;
+    return {
+        acquire: async (key, acquireOptions = {}) => {
+            const paths = getPathsForKey(rootDir, key);
+            await ensureLockDirectories(paths);
+            const createdAt = Date.now();
+            const ticketId = createTicketId(createdAt, pid);
+            const ticketPath = path.join(paths.queueDir, `${ticketId}.json`);
+            const metadata = {
+                ticketId,
+                key,
+                pid,
+                createdAt,
+                heartbeatAt: createdAt,
+            };
+            await fs.writeFile(ticketPath, JSON.stringify(metadata), 'utf8');
+            scopedLogger.debug('queued ticket %s for key %s', ticketId, key);
+            let heartbeatTimer = null;
+            let heartbeatInFlight = false;
+            let released = false;
+            let didNotifyWait = false;
+            const waitStartedAt = Date.now();
+            const release = async () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = null;
+                }
+                const owner = await readJsonFile(paths.ownerFilePath);
+                if (owner?.ticketId === ticketId) {
+                    await removeFileIfPresent(paths.ownerFilePath);
+                }
+                await removeFileIfPresent(ticketPath);
+                scopedLogger.debug('released ticket %s for key %s', ticketId, key);
+            };
+            const startHeartbeat = () => {
+                heartbeatTimer = setInterval(async () => {
+                    if (heartbeatInFlight) {
+                        return;
+                    }
+                    heartbeatInFlight = true;
+                    try {
+                        const nextHeartbeatAt = Date.now();
+                        const owner = await readJsonFile(paths.ownerFilePath);
+                        if (released || owner?.ticketId !== ticketId) {
+                            return;
+                        }
+                        const nextMetadata = {
+                            ...owner,
+                            heartbeatAt: nextHeartbeatAt,
+                        };
+                        if (released) {
+                            return;
+                        }
+                        await writeJsonFileAtomic(paths.ownerFilePath, nextMetadata);
+                        scopedLogger.debug('refreshed heartbeat for ticket %s', ticketId);
+                    }
+                    finally {
+                        heartbeatInFlight = false;
+                    }
+                }, heartbeatIntervalMs);
+                heartbeatTimer.unref?.();
+            };
+            try {
+                while (true) {
+                    acquireOptions.signal?.throwIfAborted();
+                    const now = Date.now();
+                    const activeTickets = await cleanupQueue({
+                        paths,
+                        currentTicketId: ticketId,
+                        logger: scopedLogger,
+                        isProcessActive,
+                    });
+                    const ownIndex = activeTickets.findIndex((entry) => entry.ticketId === ticketId);
+                    if (ownIndex === -1) {
+                        throw new Error(`Queued ticket ${ticketId} disappeared before acquisition.`);
+                    }
+                    const owner = await maybeClearStaleOwner({
+                        ownerFilePath: paths.ownerFilePath,
+                        staleLockTimeoutMs,
+                        now,
+                        logger: scopedLogger,
+                        isProcessActive,
+                    });
+                    if (ownIndex === 0 && owner === null) {
+                        const claimed = await claimOwnership(paths.ownerFilePath, {
+                            ...metadata,
+                            heartbeatAt: Date.now(),
+                        });
+                        if (claimed) {
+                            await removeFileIfPresent(ticketPath);
+                            startHeartbeat();
+                            scopedLogger.debug('acquired lock for key %s with ticket %s', key, ticketId);
+                            return { release };
+                        }
+                    }
+                    if (!didNotifyWait) {
+                        didNotifyWait = true;
+                        acquireOptions.onWait?.();
+                    }
+                    acquireOptions.onStillWaiting?.(Date.now() - waitStartedAt);
+                    scopedLogger.debug('waiting for key %s with ticket %s at queue position %d', key, ticketId, ownIndex + 1);
+                    await waitForPollInterval(pollIntervalMs, acquireOptions.signal);
+                }
+            }
+            catch (error) {
+                await release();
+                throw error;
+            }
+        },
+    };
+};

package/dist/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AA2CxD,eAAO,MAAM,KAAK,GAAU,cAAc,UAAU,CAAC,YAAY,kBA0DhE,CAAC"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AA4CxD,eAAO,MAAM,KAAK,GAAU,cAAc,UAAU,CAAC,YAAY,kBA6EhE,CAAC"}

package/dist/setup.js

@@ -5,6 +5,7 @@ import { getAdditionalCliArgs } from './cli-args.js';
 import { logTestEnvironmentReady, logTestRunHeader } from './logs.js';
 import { NoRunnerSpecifiedError, RunnerNotFoundError } from './errors.js';
 import { logger } from '@react-native-harness/tools';
+import { createActionHooksPlugin } from './action-hooks.js';
 const setupLogger = logger.child('setup');
 const getHarnessConfig = async (globalConfig) => {
     const projectRoot = globalConfig.rootDir;
@@ -45,7 +46,17 @@ export const setup = async (globalConfig) => {
             metroPort: cliArgs.metroPort,
         });
     }
+    if (process.env.PRE_RUN_HOOK || process.env.AFTER_RUN_HOOK) {
+        harnessConfig = ConfigSchema.parse({
+            ...harnessConfig,
+            plugins: [...(harnessConfig.plugins ?? []), createActionHooksPlugin()],
+        });
+    }
     const selectedRunner = getHarnessRunner(harnessConfig, cliArgs);
+    if (harnessConfig.webSocketPort != null &&
+        harnessConfig.webSocketPort !== harnessConfig.metroPort) {
+        logger.warn(`Config option "webSocketPort" is deprecated and ignored. Harness now uses metroPort (${harnessConfig.metroPort}) for bridge traffic.`);
+    }
     if (globalConfig.collectCoverage) {
         // This is going to be used by @react-native-harness/babel-preset
         // to enable instrumentation of test files.
@@ -64,6 +75,6 @@ export const setup = async (globalConfig) => {
     const harness = await getHarness(harnessConfig, selectedRunner, globalConfig.rootDir);
     logTestEnvironmentReady(selectedRunner);
     setupLogger.debug('Harness instance is ready');
-    global.HARNESS_CONFIG = harnessConfig;
+    global.HARNESS_CONFIG = harness.config;
     global.HARNESS = harness;
 };