@unrulysystems/rn-playwright-driver-runner 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @unrulysystems/rn-playwright-driver-runner
 
+## 0.2.0
+
+### Minor Changes
+
+- [#30](https://github.com/unrulysystems/rn-playwright-driver/pull/30) [`4bdbe20`](https://github.com/unrulysystems/rn-playwright-driver/commit/4bdbe2073f7b613f6bfb8d5a13db5e0ca000e1c5) Thanks [@alleneubank](https://github.com/alleneubank)! - Upgrade the dogfood example and native module tooling to Expo SDK 56.
+
+  The driver now sends a React Native inspector-compatible WebSocket Origin when
+  attaching to Hermes CDP, which keeps Expo SDK 56 dev-client debugging connected
+  on localhost Metro servers. The runner also fast-fails companion readiness when
+  captured iOS or Android companion logs contain terminal build, test, or
+  instrumentation failure markers instead of waiting for the full probe timeout.
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/cli.js

@@ -54,6 +54,10 @@ var DEFAULTS = {
   androidTokenFileName: "rn-driver-touch-token"
 };
 var SECRET_PLACEHOLDER = "<token-file>";
+var COMPANION_FAILURE_MARKERS = {
+  ios: ["** BUILD FAILED **", "** TEST FAILED **"],
+  android: ["INSTRUMENTATION_FAILED", "Process crashed"]
+};
 
 // src/plan/env.ts
 function buildIosDriverEnv(resolved, metro, timeoutMs) {
@@ -273,7 +277,10 @@ function planAndroid(input) {
         port: resolved.touchPort,
         tokenFile: resolved.tokenFile,
         timeoutMs: resolved.companionReadyTimeoutMs
-      }
+      },
+      // Abort early if `am instrument` reports the companion failed to start (crash / missing
+      // androidTest target) instead of waiting out the readiness budget.
+      failureMarkers: COMPANION_FAILURE_MARKERS.android
     }
   });
   push(launchStep("android.launch-2", android, launch2Command));
@@ -604,7 +611,10 @@ function planIos(input) {
         port: resolved.touchPort,
         tokenFile: resolved.tokenFile,
         timeoutMs: resolved.companionReadyTimeoutMs
-      }
+      },
+      // Abort early if `xcodebuild test` reports a build/test failure (it lingers "alive" after, so
+      // the 300s readiness budget would otherwise be burnt waiting for a companion that cannot bind).
+      failureMarkers: COMPANION_FAILURE_MARKERS.ios
     }
   });
   if (isDevClient) {
@@ -860,8 +870,10 @@ function renderAction(action) {
       return `write ${action.path}${action.mode ? ` (mode ${action.mode.toString(8)})` : ""}`;
     case "free-port":
       return `free-port ${action.port}`;
-    case "probe":
-      return `probe ${renderProbe(action.probe)}`;
+    case "probe": {
+      const fastFail = action.failureMarkers?.length ? ` [fast-fail on: ${action.failureMarkers.join(", ")}]` : "";
+      return `probe ${renderProbe(action.probe)}${fastFail}`;
+    }
     default: {
       const _exhaustive = action;
       throw new Error(`unhandled action: ${JSON.stringify(_exhaustive)}`);
@@ -907,6 +919,25 @@ function renderProbe(probe) {
   }
 }
 
+// src/runner/probe-failure.ts
+var ProbeFailure = class extends Error {
+  marker;
+  constructor(marker, detail) {
+    super(
+      `companion process reported a terminal failure ("${marker}") \u2014 aborting the readiness wait. The build/test failed; it will not become ready.${detail ? `
+${detail}` : ""}`
+    );
+    this.name = "ProbeFailure";
+    this.marker = marker;
+  }
+};
+function findFailureMarker(log, markers) {
+  for (const marker of markers) {
+    if (log.includes(marker)) return marker;
+  }
+  return null;
+}
+
 // src/runner/execute.ts
 var StageError = class extends Error {
   stage;
@@ -974,22 +1005,30 @@ async function runStep(step, runner, opts, processes, isAlive) {
     case "probe": {
       const key = processKeyForProbe(action.probe);
       const aliveFn = key === null ? () => true : () => isAlive(key);
-      let ready = await runner.probe(action.probe, aliveFn);
-      let remaining = action.retry?.max ?? 0;
-      while (!ready && remaining > 0) {
-        remaining -= 1;
-        if (action.retry) {
-          runner.log(`retry ${step.id}: re-running launch (${remaining} attempt(s) left)`);
-          await runner.exec(action.retry.command);
+      const watch = key !== null && action.failureMarkers && action.failureMarkers.length > 0 ? { logPath: logPathFor(opts.logDir, key), failureMarkers: action.failureMarkers } : void 0;
+      try {
+        let ready = await runner.probe(action.probe, aliveFn, watch);
+        let remaining = action.retry?.max ?? 0;
+        while (!ready && remaining > 0) {
+          remaining -= 1;
+          if (action.retry) {
+            runner.log(`retry ${step.id}: re-running launch (${remaining} attempt(s) left)`);
+            await runner.exec(action.retry.command);
+          }
+          ready = await runner.probe(action.probe, aliveFn, watch);
         }
-        ready = await runner.probe(action.probe, aliveFn);
-      }
-      if (!ready) {
-        throw new StageError(
-          step.stage,
-          step.id,
-          `readiness timed out after ${action.probe.timeoutMs}ms`
-        );
+        if (!ready) {
+          throw new StageError(
+            step.stage,
+            step.id,
+            `readiness timed out after ${action.probe.timeoutMs}ms`
+          );
+        }
+      } catch (error) {
+        if (error instanceof ProbeFailure) {
+          throw new StageError(step.stage, step.id, error.message);
+        }
+        throw error;
       }
       return;
     }
@@ -1128,10 +1167,15 @@ var NodeProcessRunner = class {
     }
     if (pids.length > 0) await delay(1e3);
   }
-  probe(probe, isAlive) {
+  probe(probe, isAlive, watch) {
     const deadline = Date.now() + probe.timeoutMs;
     const attempt = async () => {
       for (; ; ) {
+        if (watch) {
+          const log = await readWatchedLog(watch.logPath);
+          const marker = findFailureMarker(log, watch.failureMarkers);
+          if (marker) throw new ProbeFailure(marker, lastLines(log));
+        }
         if (!isAlive()) return false;
         if (await probeOnce(probe)) return true;
         if (Date.now() >= deadline) return false;
@@ -1176,6 +1220,19 @@ function delay(ms) {
     setTimeout(resolve, ms);
   });
 }
+async function readWatchedLog(path4) {
+  try {
+    return await promises.readFile(path4, "utf8");
+  } catch (error) {
+    throw new Error(
+      `cannot read companion log for fast-fail marker detection (${path4}): ${String(error)}`,
+      { cause: error }
+    );
+  }
+}
+function lastLines(text, n) {
+  return text.split("\n").filter((line) => line.trim().length > 0).slice(-12).join("\n");
+}
 async function probeOnce(probe) {
   switch (probe.kind) {
     case "metro-status":