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

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @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
+
+- [#27](https://github.com/unrulysystems/rn-playwright-driver/pull/27) [`b8eb24e`](https://github.com/unrulysystems/rn-playwright-driver/commit/b8eb24e9daef7f00605fe06dcf520089f62f58be) Thanks [@alleneubank](https://github.com/alleneubank)! - Harden the runner and driver fixtures for dev-client dogfooding.
+
+  The runner now ships a Node-compatible `rn-driver` bin, supports Android
+  Expo dev-client deep-link launch, and documents runner-owned lifecycle
+  boundaries. The driver Playwright fixture resolves `@playwright/test` from the
+  consumer project so npm and Yarn installs use the app's Playwright instance.
+
 ## 0.1.0
 
 ### Initial Release

package/README.md

@@ -29,7 +29,7 @@ this package; your Playwright specs import the driver directly.)
 ## Install
 
 ```bash
-bun add -d @unrulysystems/rn-playwright-driver-runner
+npm install --save-dev @unrulysystems/rn-playwright-driver-runner
 ```
 
 This package orchestrates the platform companions; install and configure them per
@@ -68,6 +68,8 @@ export default defineRnDriverConfig({
   android: {
     packageName: 'com.company.app',
     activity: '.MainActivity',
+    // Required only for expo-dev-client launch:
+    // scheme: 'companyapp',
     launch: { mode: 'launch', kind: 'plain' },
   },
   playwright: {
@@ -77,7 +79,34 @@ export default defineRnDriverConfig({
 ```
 
 A plain (non dev-client) Expo app uses `launch: { mode: 'launch', kind: 'plain' }`
-on iOS — the companion launches the app itself.
+on both platforms. The companion launches the app itself on iOS; Android launches
+the configured `packageName`/`activity` directly.
+
+For Expo dev-client, the host owns native app launch so the app starts on the
+test Metro instead of stopping at the launcher UI:
+
+```ts
+export default defineRnDriverConfig({
+  metro: { command: 'npx expo start --localhost --port 8081' },
+  ios: {
+    bundleId: 'com.company.app',
+    workspace: 'ios/App.xcworkspace',
+    appScheme: 'App',
+    launch: { mode: 'attach', kind: 'expo-dev-client' },
+  },
+  android: {
+    packageName: 'com.company.app',
+    activity: '.MainActivity',
+    scheme: 'companyapp',
+    launch: { mode: 'launch', kind: 'expo-dev-client' },
+  },
+})
+```
+
+`launch.initialUrl` defaults to the resolved Metro URL on iOS and Android. iOS
+uses `simctl launch --initialUrl`; Android uses the configured
+`android.scheme` to open
+`<scheme>://expo-development-client/?url=<resolved-metro-url>`.
 
 ## Run
 
@@ -128,13 +157,57 @@ Token material always travels by `0600` file path (the driver's
 `--dry-run` output. Cleanup is defensive and idempotent — a crashed prior run
 never wedges the next (stale companion ports are freed at startup and teardown).
 
+### Playwright lifecycle boundary
+
+Invoke specs through `rn-driver test`, not a standalone `playwright test`
+command. The runner starts or reuses Metro, builds and launches the native app,
+starts the companion, waits for Hermes, sets the driver env contract, runs
+Playwright, and cleans up the state it owns.
+
+Runner-managed Playwright configs should not define app-level `globalSetup` or
+`globalTeardown` that starts/stops Metro, launches the native app, starts/stops a
+touch companion, or removes runner companion state. Keep those hooks for
+test-local concerns only. Specs should consume the environment that
+`rn-driver test` provides.
+
+### Runner env contract
+
+These names are the runner-owned surface between native lifecycle setup and
+Playwright/driver execution. Token values are never exposed; only file paths are.
+
+| Variable                                                               | Scope   | Meaning                                            |
+| ---------------------------------------------------------------------- | ------- | -------------------------------------------------- |
+| `RN_METRO_URL`                                                         | both    | Metro URL the app and driver should use            |
+| `RN_DEVICE_NAME`                                                       | both    | Hermes target device-name pin                      |
+| `RN_TIMEOUT`                                                           | both    | Driver request timeout                             |
+| `RN_TOUCH_BACKEND`                                                     | both    | `xctest` on iOS, `instrumentation` on Android      |
+| `RN_TOUCH_XCTEST_PORT`, `RN_TOUCH_XCTEST_TOKEN_FILE`                   | iOS     | XCTest companion port and token-file path          |
+| `RN_TOUCH_INSTRUMENTATION_PORT`, `RN_TOUCH_INSTRUMENTATION_TOKEN_FILE` | Android | Instrumentation companion port and token-file path |
+| `ANDROID_SERIAL`                                                       | Android | adb device pin for the selected emulator/device    |
+
+The runner also owns internal token/config file paths used to start companions
+and configure native test targets. Do not pass token values through argv, inline
+env, or docs.
+
+### Prebuild environment and priming
+
+`expo prebuild` runs inside the runner process, so it inherits the runner
+process environment. The intended stable marker for test-only Expo config,
+plugins, or native settings is `RN_E2E=1`; this package does not emit that marker
+yet, so treat it as the planned contract rather than current behavior.
+
+The implemented lifecycle already covers prebuild, Metro, app launch, companion
+startup, Hermes waits, Playwright env, and cleanup. Priming controls such as
+`RN_E2E_PRIMED=1` or a `prebuild.clean` option are future design space and are
+not available runner flags today.
+
 ## Requirements
 
-- The `rn-driver` CLI runs under **bun**. The `bin` is a thin bun shim (mirroring
-  the driver's `rn-inspect`) so a TypeScript `rn-driver.config.ts` loads without a
-  separate compile step. Install bun: <https://bun.sh>.
+- The `rn-driver` CLI runs under **Node >= 22**. The published `bin` is a thin
+  Node shim that loads built JavaScript from `dist`, so npm/Yarn consumers do not
+  need bun or nub on `PATH`.
 - The readiness probes use the global `WebSocket`/`fetch`, so embedding the
-  library API (the `.` export) standalone requires **bun** or **Node >= 22**.
+  library API (the `.` export) standalone requires **Node >= 22**.
 - The platform companion packages installed and their Expo config plugins added.
 - `xcrun`/`xcodebuild`/`pod` (iOS) and `adb`/`gradle` (Android) on `PATH`.
 

package/bin/rn-driver.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { run } from '../dist/cli.mjs'
+
+try {
+  process.exitCode = await run(process.argv.slice(2))
+} catch (error) {
+  console.error(error)
+  process.exitCode = 1
+}

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) {
@@ -216,9 +220,10 @@ function planAndroid(input) {
       }
     }
   });
-  const launchCommand = launchCommandFor(android, serial);
-  push(launchStep("android.launch-1", android, serial));
-  push(hermesStep("android.hermes-1", android, metro, resolved, hermesDeviceName, launchCommand));
+  const launch1Command = launchCommandFor(android, resolved, serial, { forceStopBefore: true });
+  const launch2Command = launchCommandFor(android, resolved, serial, { forceStopBefore: false });
+  push(launchStep("android.launch-1", android, launch1Command));
+  push(hermesStep("android.hermes-1", android, metro, resolved, hermesDeviceName, launch1Command));
   push({
     id: "android.forward-clean",
     stage: "companion",
@@ -272,11 +277,14 @@ 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, serial));
-  push(hermesStep("android.hermes-2", android, metro, resolved, hermesDeviceName, launchCommand));
+  push(launchStep("android.launch-2", android, launch2Command));
+  push(hermesStep("android.hermes-2", android, metro, resolved, hermesDeviceName, launch2Command));
   const cleanup = [
     {
       type: "kill-process",
@@ -331,22 +339,34 @@ function planAndroid(input) {
     playwright: playwrightCommand(playwright, specs, passthrough)
   };
 }
-function launchCommandFor(android, serial) {
-  return adb(serial, [
-    "shell",
-    "am",
-    "start",
-    "-W",
-    "-n",
-    `${android.packageName}/${android.activity}`
-  ]);
-}
-function launchStep(id, android, serial) {
+function launchCommandFor(android, resolved, serial, opts) {
+  if (android.launch.kind === "plain") {
+    return adb(serial, [
+      "shell",
+      "am",
+      "start",
+      "-W",
+      "-n",
+      `${android.packageName}/${android.activity}`
+    ]);
+  }
+  if (!android.scheme) {
+    throw new Error('android.scheme is required when android.launch.kind is "expo-dev-client"');
+  }
+  const launchScript = `am start -a android.intent.action.VIEW -d ${shellSingleQuote(
+    devClientUrl(android.scheme, resolved.initialUrl)
+  )}`;
+  return adbShellScript(
+    serial,
+    opts.forceStopBefore ? `am force-stop ${android.packageName} && ${launchScript}` : launchScript
+  );
+}
+function launchStep(id, android, command) {
   return {
     id,
     stage: "app-launch",
     description: `Launch ${android.packageName}/${android.activity}`,
-    action: { type: "command", command: launchCommandFor(android, serial) }
+    action: { type: "command", command }
   };
 }
 function hermesStep(id, android, metro, resolved, deviceNameMatch, launchCommand) {
@@ -380,6 +400,12 @@ function debugHostXml(host) {
 function adb(serial, args) {
   return { command: "adb", args: ["-s", serial, ...args] };
 }
+function devClientUrl(scheme, initialUrl) {
+  return `${scheme}://expo-development-client/?url=${initialUrl}`;
+}
+function shellSingleQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
 function adbShellScript(serial, remote) {
   return { command: "adb", args: ["-s", serial, "shell", remote] };
 }
@@ -425,8 +451,7 @@ function planIos(input) {
       // Pass the resolved UI-test scheme so a custom `ios.uitestScheme` scaffolds
       // the SAME target that companion startup later builds (default is
       // `${appScheme}UITests`).
-      command: npx([
-        "rn-driver-xctest-scaffold",
+      command: cmd("node_modules/.bin/rn-driver-xctest-scaffold", [
         "--ios-dir",
         "ios",
         "--project-name",
@@ -586,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) {
@@ -720,7 +748,7 @@ function placeholderIos(ios, metro) {
     initialUrl: ios.launch.initialUrl ?? metro.url
   };
 }
-function placeholderAndroid(android, _metro) {
+function placeholderAndroid(android, metro) {
   return {
     serial: "<android-serial>",
     touchPort: android.companion?.port ?? DEFAULTS.companionPort,
@@ -728,7 +756,8 @@ function placeholderAndroid(android, _metro) {
     hermesTimeoutMs: DEFAULTS.hermesTargetTimeoutMs,
     tokenFile: SECRET_PLACEHOLDER,
     deviceTokenFileName: DEFAULTS.androidTokenFileName,
-    instrumentationTarget: instrumentationTarget(android)
+    instrumentationTarget: instrumentationTarget(android),
+    initialUrl: android.launch.initialUrl ?? metro.url
   };
 }
 
@@ -755,7 +784,7 @@ function buildDryRunPlan(config, platform, opts = {}) {
   return planAndroid({
     android,
     metro,
-    resolved: placeholderAndroid(android),
+    resolved: placeholderAndroid(android, metro),
     playwright: config.playwright,
     timeoutMs: config.timeoutMs,
     specs,
@@ -841,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)}`);
@@ -888,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;
@@ -955,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;
     }
@@ -1109,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;
@@ -1157,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":
@@ -1295,7 +1371,7 @@ async function resolveIosTarget(ios, metro, opts) {
     initialUrl: ios.launch.initialUrl ?? metro.url
   };
 }
-async function resolveAndroidTarget(android, _metro, opts) {
+async function resolveAndroidTarget(android, metro, opts) {
   const serial = await selectSerial(opts.device);
   await requireBooted(serial);
   const deviceName = (await capture("adb", ["-s", serial, "shell", "getprop", "ro.product.model"])).trim();
@@ -1308,7 +1384,8 @@ async function resolveAndroidTarget(android, _metro, opts) {
       hermesTimeoutMs: DEFAULTS.hermesTargetTimeoutMs,
       tokenFile,
       deviceTokenFileName: DEFAULTS.androidTokenFileName,
-      instrumentationTarget: instrumentationTarget(android)
+      instrumentationTarget: instrumentationTarget(android),
+      initialUrl: android.launch.initialUrl ?? metro.url
     },
     deviceName
   };
@@ -1413,6 +1490,7 @@ var IOS_KEYS = /* @__PURE__ */ new Set([
 var ANDROID_KEYS = /* @__PURE__ */ new Set([
   "packageName",
   "activity",
+  "scheme",
   "gradleTasks",
   "appApkPath",
   "testApkPath",
@@ -1514,6 +1592,8 @@ function validateAndroid(android, errors) {
   reportUnknownKeys("config.android", android, ANDROID_KEYS, errors);
   requireAndroidPackage("config.android.packageName", android.packageName, errors);
   requireAndroidActivity("config.android.activity", android.activity, errors);
+  if (android.scheme !== void 0)
+    requireAppScheme("config.android.scheme", android.scheme, errors);
   optionalString("config.android.appApkPath", android.appApkPath, errors);
   optionalString("config.android.testApkPath", android.testApkPath, errors);
   if (android.instrumentationTarget !== void 0)
@@ -1526,7 +1606,10 @@ function validateAndroid(android, errors) {
     errors.push("config.android.gradleTasks: expected an array of strings");
   }
   validateCompanion("config.android.companion", android.companion, errors);
-  validateLaunch("config.android.launch", android.launch, errors);
+  const launch = validateLaunch("config.android.launch", android.launch, errors);
+  if (launch?.kind === "expo-dev-client" && android.scheme === void 0) {
+    errors.push('config.android.scheme: required when android.launch.kind is "expo-dev-client"');
+  }
 }
 function validateCompanion(path4, companion, errors) {
   if (companion === void 0) return;
@@ -1572,6 +1655,7 @@ function requireString(path4, value, errors) {
 }
 var ANDROID_PACKAGE_RE = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)+$/;
 var ANDROID_ACTIVITY_RE = /^\.?[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)*$/;
+var APP_SCHEME_RE = /^[a-z][a-z0-9+.-]*$/;
 function requireAndroidPackage(path4, value, errors) {
   if (typeof value !== "string" || value.trim() === "") {
     errors.push(`${path4}: required non-empty string`);
@@ -1588,6 +1672,17 @@ function requireAndroidActivity(path4, value, errors) {
   if (!ANDROID_ACTIVITY_RE.test(value))
     errors.push(`${path4}: expected an activity name (e.g. .MainActivity)`);
 }
+function requireAppScheme(path4, value, errors) {
+  if (typeof value !== "string" || value.trim() === "") {
+    errors.push(`${path4}: required non-empty string`);
+    return;
+  }
+  if (!APP_SCHEME_RE.test(value)) {
+    errors.push(
+      `${path4}: expected a valid URL scheme (lowercase letter, then lowercase letters, digits, +, ., or -)`
+    );
+  }
+}
 var ANDROID_INSTRUMENTATION_RE = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)*\/[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)*$/;
 function requireInstrumentationTarget(path4, value, errors) {
   if (typeof value !== "string" || value.trim() === "") {