Merge remote-tracking branch 'origin/main' into feat/external-xctest

# Conflicts:
#	packages/platform-ios/src/xctest-agent.ts

Author: V3RON

.nx/version-plans/version-plan-1778581623000.md

@@ -0,0 +1,5 @@
+---
+__default__: patch
+---
+
+When `forwardClientLogs` is enabled, Harness continues attaching device `console` output to the active test result, while keeping the internal log-capture path simpler and easier to maintain.

.nx/version-plans/version-plan-1778584200000.md

@@ -0,0 +1,5 @@
+---
+__default__: patch
+---
+
+Harness now lets you build the iOS XCTest agent binary directly from the CLI, without starting a Harness test run. This makes it easier to prepare the agent artifact ahead of time for external injection workflows.

actions/shared/index.cjs

@@ -633,8 +633,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/dist/esm/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path6, errorMaps, issueData } = params;
-  const fullPath = [...path6, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -750,11 +750,11 @@ var errorUtil;
 
 // ../../node_modules/zod/dist/esm/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path6, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path6;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -4350,6 +4350,10 @@ var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
 var DEFAULT_ARTIFACT_ROOT = import_node_path4.default.join(process.cwd(), ".harness", "crash-reports");
 
+// ../tools/dist/harness-artifacts.js
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+
 // ../plugins/dist/utils.js
 var isHookTree = (value) => {
   if (value == null || typeof value !== "object" || Array.isArray(value)) {
@@ -4396,6 +4400,7 @@ var RunnerSchema = external_exports.object({
   name: external_exports.string().min(1, "Runner name is required").regex(/^[a-zA-Z0-9._-]+$/, "Runner name can only contain alphanumeric characters, dots, underscores, and hyphens"),
   config: external_exports.record(external_exports.any()),
   runner: external_exports.string(),
+  cli: external_exports.string().optional(),
   platformId: external_exports.string()
 });
 var PluginSchema = external_exports.custom((value) => isHarnessPlugin(value), "Invalid Harness plugin");
@@ -4502,16 +4507,16 @@ var ConfigLoadError = class extends HarnessError {
 };
 
 // ../config/dist/reader.js
-var import_node_path5 = __toESM(require("path"), 1);
-var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
 var import_node_module2 = require("module");
 var import_meta = {};
 var extensions = [".js", ".mjs", ".cjs", ".json"];
 var importUp = async (dir, name) => {
-  const filePath = import_node_path5.default.join(dir, name);
+  const filePath = import_node_path6.default.join(dir, name);
   for (const ext of extensions) {
     const filePathWithExt = `${filePath}${ext}`;
-    if (import_node_fs5.default.existsSync(filePathWithExt)) {
+    if (import_node_fs6.default.existsSync(filePathWithExt)) {
       let rawConfig;
       try {
         if (ext === ".mjs") {
@@ -4529,16 +4534,16 @@ var importUp = async (dir, name) => {
       } catch (error) {
         if (error instanceof ZodError) {
           const validationErrors = error.errors.map((err) => {
-            const path6 = err.path.length > 0 ? ` at "${err.path.join(".")}"` : "";
-            return `${err.message}${path6}`;
+            const path7 = err.path.length > 0 ? ` at "${err.path.join(".")}"` : "";
+            return `${err.message}${path7}`;
           });
           throw new ConfigValidationError(filePathWithExt, validationErrors);
         }
         throw error;
       }
     }
   }
-  const parentDir = import_node_path5.default.dirname(dir);
+  const parentDir = import_node_path6.default.dirname(dir);
   if (parentDir === dir) {
     throw new ConfigNotFoundError(dir);
   }
@@ -4553,8 +4558,8 @@ var getConfig = async (dir) => {
 };
 
 // src/shared/index.ts
-var import_node_path6 = __toESM(require("path"));
-var import_node_fs6 = __toESM(require("fs"));
+var import_node_path7 = __toESM(require("path"));
+var import_node_fs7 = __toESM(require("fs"));
 var getHostAndroidSystemImageArch = () => {
   switch (process.arch) {
     case "arm64":
@@ -4622,7 +4627,7 @@ var run = async () => {
     if (!runnerInput) {
       throw new Error("Runner input is required");
     }
-    const projectRoot = projectRootInput ? import_node_path6.default.resolve(projectRootInput) : process.cwd();
+    const projectRoot = projectRootInput ? import_node_path7.default.resolve(projectRootInput) : process.cwd();
     console.info(`Loading React Native Harness config from: ${projectRoot}`);
     const { config, projectRoot: resolvedProjectRoot } = await getConfig(
       projectRoot
@@ -4636,13 +4641,13 @@ var run = async () => {
       throw new Error("GITHUB_OUTPUT environment variable is not set");
     }
     const resolvedRunner = getResolvedRunner(runner);
-    const relativeProjectRoot = import_node_path6.default.relative(process.cwd(), resolvedProjectRoot) || ".";
+    const relativeProjectRoot = import_node_path7.default.relative(process.cwd(), resolvedProjectRoot) || ".";
     const output = `config=${JSON.stringify(
       resolvedRunner
     )}
 projectRoot=${relativeProjectRoot}
 `;
-    import_node_fs6.default.appendFileSync(githubOutput, output);
+    import_node_fs7.default.appendFileSync(githubOutput, output);
   } catch (error) {
     if (error instanceof Error) {
       console.error(error.message);

packages/babel-preset/src/resolve-weak-plugin.ts

@@ -6,6 +6,11 @@ const FUNCTIONS_REQUIRING_RESOLVE_WEAK = [
   'unmock',
   'requireActual',
 ] as const;
+type ResolveWeakFunctionName = (typeof FUNCTIONS_REQUIRING_RESOLVE_WEAK)[number];
+const isResolveWeakFunctionName = (
+  value: string
+): value is ResolveWeakFunctionName =>
+  FUNCTIONS_REQUIRING_RESOLVE_WEAK.includes(value as ResolveWeakFunctionName);
 
 const resolveWeakPlugin = ({
   types: t,
@@ -41,7 +46,7 @@ const resolveWeakPlugin = ({
           // Only transform if the function was imported from react-native-harness
           if (
             importedNames.has(functionName) &&
-            FUNCTIONS_REQUIRING_RESOLVE_WEAK.includes(functionName as any)
+            isResolveWeakFunctionName(functionName)
           ) {
             const firstArg = node.arguments[0];
 

packages/bridge/src/binary-transfer.ts

@@ -32,7 +32,7 @@ export function parseBinaryFrame(frame: Uint8Array): {
 
 export class BinaryStore {
   private store = new Map<number, Uint8Array>();
-  private timeouts = new Map<number, any>();
+  private timeouts = new Map<number, ReturnType<typeof setTimeout>>();
   // 5 minutes timeout for binary data
   private readonly TIMEOUT_MS = 5 * 60 * 1000;
 

packages/bridge/src/client.ts

@@ -1,19 +1,63 @@
-import { BirpcReturn, createBirpc } from 'birpc';
-import type { BridgeClientFunctions, BridgeServerFunctions } from './shared.js';
+import { createBirpc } from 'birpc';
 import { deserialize, serialize } from './serializer.js';
-import { createBinaryFrame } from './binary-transfer.js';
+import { createBinaryFrame, generateTransferId } from './binary-transfer.js';
+import type {
+  BridgeClientFunctions,
+  BridgeServerFunctions,
+  DeviceDescriptor,
+  BridgeEvents,
+  FileReference,
+  ImageSnapshotOptions,
+  TestExecutionOptions,
+  TestSuiteResult,
+} from './shared.js';
 
-export type BridgeClient = {
-  rpc: BirpcReturn<BridgeServerFunctions, BridgeClientFunctions>;
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/** Handlers the app must implement for the CLI to call into. */
+export type HarnessCallbacks = {
+  runTests: (path: string, options: TestExecutionOptions) => Promise<TestSuiteResult>;
+};
+
+/** The app-side handle returned by connectToHarness. */
+export type HarnessHandle = {
+  /** Call once when the app is initialised and ready to run tests. */
+  reportReady: (device: DeviceDescriptor) => void;
+  /** Forward a test or bundler event to the CLI. */
+  emitEvent: (event: BridgeEvents) => void;
+  /** Send a screenshot to the CLI and receive a file reference for snapshot comparison. */
+  transferScreenshot: (
+    data: Uint8Array,
+    metadata: { width: number; height: number },
+  ) => Promise<FileReference>;
+  /** Request an image snapshot comparison on the CLI. */
+  matchImageSnapshot: (
+    screenshot: FileReference,
+    testPath: string,
+    options: ImageSnapshotOptions,
+    runner: string,
+  ) => Promise<{ pass: boolean; message: string }>;
   disconnect: () => void;
-  sendBinary: (transferId: number, data: Uint8Array) => void;
 };
 
-const getBridgeClient = async (
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Connect the app to the CLI harness bridge.
+ *
+ * Pass the handlers the CLI can call (runTests). Returns a HarnessHandle
+ * exposing the operations the app needs to drive a test run. The binary
+ * transfer protocol and RPC wiring are fully encapsulated.
+ */
+export const connectToHarness = (
   url: string,
-  handlers: BridgeClientFunctions,
-): Promise<BridgeClient> => {
-  return new Promise((resolve, reject) => {
+  callbacks: HarnessCallbacks,
+): Promise<HarnessHandle> =>
+  new Promise((resolve, reject) => {
     const ws = new WebSocket(url);
     ws.binaryType = 'arraybuffer';
     let settled = false;
@@ -24,11 +68,8 @@ const getBridgeClient = async (
       ws.removeEventListener('close', handleClose);
     };
 
-    const rejectConnection = (message: string) => {
-      if (settled) {
-        return;
-      }
-
+    const fail = (message: string) => {
+      if (settled) return;
       settled = true;
       cleanup();
       reject(new Error(message));
@@ -39,56 +80,53 @@ const getBridgeClient = async (
       cleanup();
 
       const rpc = createBirpc<BridgeServerFunctions, BridgeClientFunctions>(
-        handlers,
+        callbacks,
         {
           post: (data) => ws.send(data),
           on: (handler) => {
-            ws.addEventListener('message', (event: any) => {
-              if (typeof event.data === 'string') {
-                handler(event.data);
-              }
+            ws.addEventListener('message', (event: MessageEvent<string | ArrayBuffer>) => {
+              if (typeof event.data === 'string') handler(event.data);
             });
           },
           serialize,
           deserialize,
         },
       );
 
-      const client: BridgeClient = {
-        rpc,
-        disconnect: () => {
-          ws.close();
-        },
-        sendBinary: (transferId: number, data: Uint8Array) => {
-          const frame = createBinaryFrame(transferId, data);
-          ws.send(frame);
+      resolve({
+        reportReady: (device) => void rpc.reportReady(device),
+        emitEvent: (event) => void rpc.emitEvent(event.type, event),
+        transferScreenshot: async (data, metadata) => {
+          const transferId = generateTransferId();
+          ws.send(createBinaryFrame(transferId, data));
+          return rpc['device.screenshot.receive'](
+            { type: 'binary', transferId, size: data.length, mimeType: 'image/png' },
+            metadata,
+          );
         },
-      };
-
-      resolve(client);
+        matchImageSnapshot: (screenshot, testPath, options, runner) =>
+          rpc['test.matchImageSnapshot'](screenshot, testPath, options, runner),
+        disconnect: () => ws.close(),
+      });
     };
 
     const handleError = (event: Event & { message?: string }) => {
-      const reason =
-        typeof event.message === 'string' && event.message.length > 0
+      const detail =
+        typeof event.message === 'string' && event.message
           ? `: ${event.message}`
           : '';
-
-      rejectConnection(
-        `Failed to connect to the Harness bridge at ${url}${reason}`,
-      );
+      fail(`Failed to connect to Harness at ${url}${detail}`);
     };
 
     const handleClose = (event: CloseEvent) => {
-      rejectConnection(
-        `Harness bridge connection to ${url} closed before it became ready (code ${event.code}${event.reason ? `, reason: ${event.reason}` : ''})`,
+      fail(
+        `Harness connection at ${url} closed before becoming ready (code ${event.code}${
+          event.reason ? `, reason: ${event.reason}` : ''
+        })`,
       );
     };
 
     ws.addEventListener('open', handleOpen);
     ws.addEventListener('error', handleError);
     ws.addEventListener('close', handleClose);
   });
-};
-
-export { getBridgeClient };