@deeeed/metamask-harness 0.42.0 → 0.43.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## 0.43.0 - 2026-08-21
+
+### Added
+
+- Add platform-neutral `app.performance_capture` and `app.performance_assert` actions that attribute Mobile or Extension CDP trace samples to exact recipe-node boundaries and emit JSON plus self-contained HTML evidence.
+- Mobile native UI FPS requires a development client that reports `unstable_frameRecordingEnabled: true`; unpatched clients report partial or unavailable native coverage. Extension uses Chromium CDP and needs no client patch.
+
+### Fixed
+
+- Bound performance capture duration, discard raw samples after node attribution, correct iOS frame completion timestamps, fail closed on unresolved Extension renderers, and reset CDP collector state after trace failures.
+- Scope Mobile Hermes broker ownership by checkout runtime and Metro port so a forwarder from a prior port cannot intercept bridge, HUD, or observation commands after a slot port change.
+- Preserve explicit Mobile `--device` pins when slot defaults load so HUD and live-adapter child processes cannot target another device.
+- Resume broker commands on the next Hermes session generation without losing the pinned logical device.
+- Keep Hermes session recovery inside the caller's RPC deadline, pass only the remaining time to the recovered command, and classify broker connection or request timeouts so transient HUD updates do not abort a recipe.
+- Accept React Native trace response chunks up to 16 MiB while keeping broker requests capped at 8 MiB, and never retry the non-idempotent `Tracing.end` command.
+- Limit Mobile UI captures to clock and native-frame categories; keep browser timeline and JavaScript task categories on Extension.
+
 ## 0.42.0 - 2026-08-20
 
 ### Added

package/README.md

@@ -116,6 +116,11 @@ explicit `app.network_capture` and `app.network_assert` nodes for filtered
 windows and machine-checked request expectations. See
 [Recipe-scoped network capture](docs/NETWORK-CAPTURE.md).
 
+Mobile and Extension recipes can bracket explicit UI-smoothness windows with
+`app.performance_capture` and verify their evidence with
+`app.performance_assert`. Capture is never automatic. See
+[UI smoothness capture](docs/PERFORMANCE-CAPTURE.md).
+
 ## Discover and prove
 
 ```bash

package/adapters/mobile/bridge-runtime/cdp-bridge.cjs

@@ -21,7 +21,6 @@ const path = require('node:path');
 const { loadPort } = require('./lib/config.cjs');
 const {
   discoverTarget,
-  rankRuntimeCandidates,
 } = require('./lib/target-discovery.cjs');
 const { createWSClient } = require('./lib/ws-client.cjs');
 const {
@@ -961,7 +960,6 @@ const BRIDGE_LOCK_FILE = path.join(
   process.env.RECIPE_RUNTIME_DIR || path.join('temp', 'recipe', 'runtime'),
   'cdp-bridge.lock',
 );
-const BROKER_SOCKET_FILE = brokerSocketPath(path.dirname(BRIDGE_LOCK_FILE));
 const BRIDGE_LOCK_OWNER_PID = /^\d+$/.test(
   process.env.CDP_BRIDGE_LOCK_OWNER_PID || '',
 )
@@ -1063,30 +1061,70 @@ Environment:
   }
 
   const port = loadPort();
+  const brokerSocketFile = brokerSocketPath(
+    path.dirname(BRIDGE_LOCK_FILE),
+    port,
+  );
   const timeout = Number.parseInt(process.env.CDP_TIMEOUT || '5000', 10);
-  const brokerAvailable = fs.existsSync(BROKER_SOCKET_FILE);
+  const brokerAvailable = fs.existsSync(brokerSocketFile);
   if (!brokerAvailable) acquireBridgeLock();
 
-  async function brokerTargets() {
-    const response = await fetch(`http://127.0.0.1:${port}/json/list`);
-    if (!response.ok) throw new Error(`Metro target listing returned ${response.status}`);
-    const ranked = rankRuntimeCandidates(await response.json());
-    const picked = new Set();
-    return ranked.flatMap((target) => {
-      const deviceId = deviceIdFromUrl(target.webSocketDebuggerUrl);
-      if (picked.has(deviceId)) return [];
-      picked.add(deviceId);
-      return [{
-        wsUrl: target.webSocketDebuggerUrl,
-        deviceName: target.deviceName || '',
-      }];
-    });
+  function selectedTargetPin() {
+    const platform = String(process.env.MM_HARNESS_EXPLICIT_PLATFORM || '').toLowerCase();
+    const androidPin =
+      process.env.ANDROID_TARGET_DEVICE_NAME || process.env.ANDROID_DEVICE || '';
+    const iosPin = process.env.IOS_SIMULATOR || '';
+    return String(
+      platform === 'android'
+        ? androidPin
+        : platform === 'ios'
+          ? iosPin
+          : androidPin || iosPin,
+    ).trim();
+  }
+
+  async function brokerTargets({ retainIdentity = false } = {}) {
+    const discoveryClient = await createBrokerClient(
+      brokerSocketFile,
+      '',
+      timeout,
+    );
+    try {
+      const targets = await discoveryClient.control(
+        retainIdentity ? 'resolve-targets' : 'list-targets',
+        retainIdentity ? { nameIncludes: selectedTargetPin() } : {},
+        timeout,
+      );
+      return (Array.isArray(targets) ? targets : []).flatMap((target) => {
+        const deviceId = String(target?.deviceId || '');
+        return deviceId
+          ? [{ wsUrl: deviceId, deviceName: String(target?.name || '') }]
+          : [];
+      });
+    } finally {
+      discoveryClient.close();
+    }
+  }
+
+  function selectBrokerTarget(targets) {
+    const pin = selectedTargetPin();
+    const candidates = pin
+      ? targets.filter((target) =>
+          target.deviceName.toLowerCase().includes(pin.toLowerCase()),
+        )
+      : targets;
+    if (candidates.length !== 1) {
+      throw new Error(
+        `Mobile CDP broker target selection requires one target; found ${candidates.length}${pin ? ` for ${JSON.stringify(pin)}` : ''}.`,
+      );
+    }
+    return candidates[0];
   }
 
   async function clientFor(wsUrl) {
     if (brokerAvailable) {
       return createBrokerClient(
-        BROKER_SOCKET_FILE,
+        brokerSocketFile,
         deviceIdFromUrl(wsUrl),
         timeout,
       );
@@ -1125,9 +1163,9 @@ Environment:
     return;
   }
 
-  const { wsUrl, deviceName } = await discoverTarget(port, {
-    probe: !brokerAvailable,
-  });
+  const { wsUrl, deviceName } = brokerAvailable
+    ? selectBrokerTarget(await brokerTargets({ retainIdentity: true }))
+    : await discoverTarget(port, { probe: true });
   if (!wsUrl) throw new Error('No broker-owned Hermes target is available');
   const client = await clientFor(wsUrl);
 

package/adapters/mobile/bridge-runtime/console-forwarder.cjs

@@ -35,6 +35,7 @@ const {
   deviceIdFromUrl,
 } = require('./lib/cdp-broker.cjs');
 const { createDevtoolsProxy } = require('./lib/devtools-proxy.cjs');
+const { resolvePort } = require('./lib/config.cjs');
 
 // Hermes uses Node's built-in WebSocket client. The local DevTools proxy uses
 // the package's pinned `ws` server implementation.
@@ -46,7 +47,7 @@ const FLUSH_MS = 100;
 const MAX_LINE_CHARS = 4000;
 
 function parseArgs(argv) {
-  const args = { port: process.env.WATCHER_PORT || '8081', out: null };
+  const args = { port: resolvePort(), out: null };
   for (let i = 2; i < argv.length; i += 1) {
     if (argv[i] === '--port') args.port = argv[++i];
     else if (argv[i] === '--out') args.out = argv[++i];
@@ -208,7 +209,7 @@ function sendCommand(session, method, params = {}, timeoutMs = 10_000) {
 }
 
 broker = createCdpBroker({
-  socketPath: brokerSocketPath(path.dirname(out)),
+  socketPath: brokerSocketPath(path.dirname(out), port),
   sessions,
   sendCommand,
   requestDiscovery(deviceId) {

package/adapters/mobile/bridge-runtime/lib/bridge-errors.cjs

@@ -63,6 +63,8 @@ const NEEDLE_CODES = [
   ['websocket error', BRIDGE_ERROR_CODES.WS_CLOSED],
   ['cdp connection timeout', BRIDGE_ERROR_CODES.CDP_TIMEOUT],
   ['cdp message timeout', BRIDGE_ERROR_CODES.CDP_TIMEOUT],
+  ['cdp broker connection timeout', BRIDGE_ERROR_CODES.CDP_TIMEOUT],
+  ['cdp broker request timeout', BRIDGE_ERROR_CODES.CDP_TIMEOUT],
   ['evaluation timed out', BRIDGE_ERROR_CODES.CDP_TIMEOUT],
   ['timed out', BRIDGE_ERROR_CODES.CDP_TIMEOUT],
 ];

package/adapters/mobile/bridge-runtime/lib/cdp-broker.cjs

@@ -12,7 +12,8 @@ const MAX_ACTIVE_CAPTURES = 16;
 const MAX_COMPLETED_CAPTURES = 16;
 const MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
 const MAX_POST_DATA_BYTES = 64 * 1024;
-const MAX_RPC_FRAME_BYTES = 8 * 1024 * 1024;
+const MAX_REQUEST_FRAME_BYTES = 8 * 1024 * 1024;
+const MAX_RESPONSE_FRAME_BYTES = 16 * 1024 * 1024;
 const MAX_RETAINED_STRING_LENGTH = 256;
 const MAX_BROKER_TIMEOUT_MS = 60_000;
 const SENSITIVE_FIELD =
@@ -20,14 +21,18 @@ const SENSITIVE_FIELD =
 const SENSITIVE_VALUE =
   /(?:0x[a-f0-9]{40,}|[a-f0-9]{64,}|eyJ[a-z0-9_-]{20,}\.[a-z0-9_-]{20,})/iu;
 
-function brokerSocketPath(runtimeDir) {
+function brokerSocketPath(runtimeDir, endpointIdentity) {
   const runtimePath = path.resolve(
     runtimeDir ||
       process.env.RECIPE_RUNTIME_DIR ||
       path.join('temp', 'recipe', 'runtime'),
   );
+  const socketIdentity =
+    endpointIdentity === undefined || endpointIdentity === null
+      ? runtimePath
+      : `${runtimePath}\u0000${String(endpointIdentity)}`;
   const identity = createHash('sha256')
-    .update(runtimePath)
+    .update(socketIdentity)
     .digest('hex')
     .slice(0, 20);
   return path.join('/tmp', `mmh-cdp-${identity}.sock`);
@@ -77,6 +82,23 @@ function boundedTimeout(value, fallback = 10_000) {
     : fallback;
 }
 
+// State recovery is event-driven. Pick a fixed bound below the caller's RPC
+// deadline so the broker always answers before the client gives up. Returning
+// literals also keeps the timer independent from untrusted request values.
+function stateWaitTimeout(value) {
+  const timeout = boundedTimeout(value);
+  if (timeout <= 500) return 1;
+  if (timeout <= 1_000) return 400;
+  if (timeout <= 2_000) return 900;
+  if (timeout <= 5_000) return 1_900;
+  if (timeout <= 10_000) return 4_500;
+  if (timeout <= 15_000) return 9_500;
+  if (timeout <= 30_000) return 14_500;
+  if (timeout <= 45_000) return 29_500;
+  if (timeout <= 55_000) return 44_500;
+  return 54_500;
+}
+
 function readField(value, field) {
   let current = value;
   for (const segment of String(field).split('.')) {
@@ -333,6 +355,25 @@ function createCdpBroker({
   const completedCaptures = new Map();
   const clients = new Set();
   const subscriptions = new Map();
+  const knownTargets = new Map(
+    [...sessions.entries()].flatMap(([deviceId, session]) =>
+      session?.brokerReady
+        ? [[deviceId, {
+            deviceId,
+            generation: 1,
+            name: String(session.name || ''),
+            ready: true,
+          }]]
+        : [],
+    ),
+  );
+  const sessionWaiters = new Map();
+  const targetWaiters = new Set();
+  const observedSessions = new Map(
+    [...sessions.entries()].flatMap(([deviceId, session]) =>
+      session?.brokerReady ? [[deviceId, session]] : [],
+    ),
+  );
 
   const capturesFor = (deviceId) => {
     if (!captures.has(deviceId)) captures.set(deviceId, new Map());
@@ -346,23 +387,83 @@ function createCdpBroker({
     return completedCaptures.get(deviceId);
   };
 
-  async function waitForSession(deviceId, timeoutMs) {
+  function targetList({ nameIncludes = '', readyOnly = false } = {}) {
+    const pin = String(nameIncludes).trim().toLowerCase();
+    return [...knownTargets.values()]
+      .filter((target) => !readyOnly || target.ready)
+      .filter((target) => !pin || target.name.toLowerCase().includes(pin))
+      .map((target) => ({ ...target }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  function settleTargetWaiters() {
+    for (const waiter of [...targetWaiters]) {
+      const targets = targetList({ nameIncludes: waiter.nameIncludes });
+      if (targets.length === 0) continue;
+      targetWaiters.delete(waiter);
+      clearTimeout(waiter.timer);
+      waiter.resolve(targets);
+    }
+  }
+
+  function resolveTargets(params, timeoutMs, socket) {
+    const existing = targetList({ nameIncludes: params.nameIncludes });
+    if (existing.length > 0) return Promise.resolve(existing);
+    requestDiscovery?.('');
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        nameIncludes: String(params.nameIncludes || ''),
+        resolve,
+        reject,
+        socket,
+        timer: null,
+      };
+      waiter.timer = setTimeout(() => {
+        targetWaiters.delete(waiter);
+        reject(new Error('CDP broker never observed the requested target'));
+      }, stateWaitTimeout(timeoutMs));
+      targetWaiters.add(waiter);
+      settleTargetWaiters();
+    });
+  }
+
+  function waitForSession(deviceId, timeoutMs, socket) {
     if (sessions.get(deviceId)?.brokerReady) return sessions.get(deviceId);
     requestDiscovery?.(deviceId);
-    const deadline = Date.now() + boundedTimeout(timeoutMs);
-    while (Date.now() < deadline) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
+    return new Promise((resolve, reject) => {
+      const waiters = sessionWaiters.get(deviceId) || new Set();
+      const waiter = {
+        resolve,
+        reject,
+        socket,
+        timer: setTimeout(() => {
+          waiters.delete(waiter);
+          if (waiters.size === 0) sessionWaiters.delete(deviceId);
+          reject(new Error(`CDP broker target unavailable: ${deviceId}`));
+        }, stateWaitTimeout(timeoutMs)),
+      };
+      waiters.add(waiter);
+      sessionWaiters.set(deviceId, waiters);
       const session = sessions.get(deviceId);
-      if (session?.brokerReady) return session;
-    }
-    throw new Error('CDP broker target unavailable');
+      if (session?.brokerReady) {
+        waiters.delete(waiter);
+        if (waiters.size === 0) sessionWaiters.delete(deviceId);
+        clearTimeout(waiter.timer);
+        resolve(session);
+      }
+    });
   }
 
-  async function enableNetwork(deviceId, capture, timeoutMs = 10_000) {
+  async function enableNetwork(
+    deviceId,
+    capture,
+    timeoutMs = 10_000,
+    socket,
+  ) {
     try {
       const budgetMs = boundedTimeout(timeoutMs);
       const deadline = Date.now() + budgetMs;
-      const session = await waitForSession(deviceId, budgetMs);
+      const session = await waitForSession(deviceId, budgetMs, socket);
       const remainingMs = Math.max(1, deadline - Date.now());
       await sendCommand(session, 'Network.enable', {}, remainingMs);
       if (capture.enableErrors.length > 0) capture.partial = true;
@@ -422,15 +523,21 @@ function createCdpBroker({
     };
   }
 
-  async function control(deviceId, action, params, timeoutMs = 10_000) {
+  async function control(
+    deviceId,
+    action,
+    params,
+    timeoutMs = 10_000,
+    socket,
+  ) {
     if (action === 'list-targets') {
-      return [...sessions.entries()]
-        .filter(([, session]) => session.brokerReady)
-        .map(([activeDeviceId, session]) => ({
-          deviceId: activeDeviceId,
-          name: String(session.name || ''),
-        }))
-        .sort((a, b) => a.name.localeCompare(b.name));
+      return targetList({ readyOnly: true }).map(({ deviceId, name }) => ({
+        deviceId,
+        name,
+      }));
+    }
+    if (action === 'resolve-targets') {
+      return resolveTargets(params, timeoutMs, socket);
     }
     if (action === 'capture-start') {
       const capture = normalizeCapture(params);
@@ -443,7 +550,12 @@ function createCdpBroker({
       }
       completedCapturesFor(deviceId).delete(capture.id);
       deviceCaptures.set(capture.id, capture);
-      await enableNetwork(deviceId, capture, Math.max(1, timeoutMs - 500));
+      await enableNetwork(
+        deviceId,
+        capture,
+        Math.max(1, timeoutMs - 500),
+        socket,
+      );
       return { id: capture.id, status: 'started' };
     }
     if (action === 'capture-end') {
@@ -467,15 +579,18 @@ function createCdpBroker({
     try {
       onClientActivity?.();
       if (request.type === 'command') {
+        const budgetMs = boundedTimeout(request.timeoutMs);
+        const deadline = Date.now() + budgetMs;
         const session = await waitForSession(
           request.deviceId,
-          boundedTimeout(request.timeoutMs),
+          budgetMs,
+          socket,
         );
         const result = await sendCommand(
           session,
           request.method,
           request.params || {},
-          boundedTimeout(request.timeoutMs),
+          Math.max(1, deadline - Date.now()),
         );
         writeMessage(socket, { id: request.id, result });
         return;
@@ -486,6 +601,7 @@ function createCdpBroker({
           request.action,
           request.params || {},
           boundedTimeout(request.timeoutMs),
+          socket,
         );
         writeMessage(socket, { id: request.id, result });
         return;
@@ -532,7 +648,7 @@ function createCdpBroker({
     socket.setEncoding('utf8');
     socket.on('data', (chunk) => {
       buffer += chunk;
-      if (Buffer.byteLength(buffer) > MAX_RPC_FRAME_BYTES) {
+      if (Buffer.byteLength(buffer) > MAX_REQUEST_FRAME_BYTES) {
         writeMessage(socket, { error: 'CDP broker request exceeds its bound' });
         socket.destroy();
         return;
@@ -556,6 +672,21 @@ function createCdpBroker({
     const drop = () => {
       clients.delete(socket);
       subscriptions.delete(socket);
+      for (const waiter of [...targetWaiters]) {
+        if (waiter.socket !== socket) continue;
+        targetWaiters.delete(waiter);
+        clearTimeout(waiter.timer);
+        waiter.reject(new Error('CDP broker client closed'));
+      }
+      for (const [deviceId, waiters] of sessionWaiters) {
+        for (const waiter of [...waiters]) {
+          if (waiter.socket !== socket) continue;
+          waiters.delete(waiter);
+          clearTimeout(waiter.timer);
+          waiter.reject(new Error('CDP broker client closed'));
+        }
+        if (waiters.size === 0) sessionWaiters.delete(deviceId);
+      }
     };
     socket.on('close', drop);
     socket.on('error', drop);
@@ -568,12 +699,38 @@ function createCdpBroker({
 
   return {
     onSessionOpen(deviceId) {
+      const session = sessions.get(deviceId);
+      if (!session?.brokerReady) return;
+      const previous = knownTargets.get(deviceId);
+      const sessionChanged = observedSessions.get(deviceId) !== session;
+      knownTargets.set(deviceId, {
+        deviceId,
+        generation:
+          previous?.generation === undefined
+            ? 1
+            : previous.generation + (!previous.ready || sessionChanged ? 1 : 0),
+        name: String(session.name || previous?.name || ''),
+        ready: true,
+      });
+      observedSessions.set(deviceId, session);
+      const waiters = sessionWaiters.get(deviceId);
+      if (waiters) {
+        sessionWaiters.delete(deviceId);
+        for (const waiter of waiters) {
+          clearTimeout(waiter.timer);
+          waiter.resolve(session);
+        }
+      }
+      settleTargetWaiters();
       for (const capture of capturesFor(deviceId).values()) {
         if (capture.reconnects > 0) capture.partial = true;
         void enableNetwork(deviceId, capture);
       }
     },
     onSessionClose(deviceId) {
+      const previous = knownTargets.get(deviceId);
+      if (previous) knownTargets.set(deviceId, { ...previous, ready: false });
+      observedSessions.delete(deviceId);
       for (const capture of capturesFor(deviceId).values()) {
         capture.reconnects += 1;
         capture.partial = true;
@@ -621,6 +778,18 @@ function createCdpBroker({
     },
     close() {
       clearInterval(expirySweep);
+      for (const waiters of sessionWaiters.values()) {
+        for (const waiter of waiters) {
+          clearTimeout(waiter.timer);
+          waiter.reject(new Error('CDP broker closed'));
+        }
+      }
+      sessionWaiters.clear();
+      for (const waiter of targetWaiters) {
+        clearTimeout(waiter.timer);
+        waiter.reject(new Error('CDP broker closed'));
+      }
+      targetWaiters.clear();
       for (const socket of clients) socket.destroy();
       try {
         server.close();
@@ -696,7 +865,7 @@ function createBrokerClient(socketPath, deviceId, timeout) {
     });
     socket.on('data', (chunk) => {
       buffer += chunk;
-      if (Buffer.byteLength(buffer) > MAX_RPC_FRAME_BYTES) {
+      if (Buffer.byteLength(buffer) > MAX_RESPONSE_FRAME_BYTES) {
         socket.destroy();
         for (const entry of pending.values()) {
           entry.reject(new Error('CDP broker response exceeds its bound'));

package/adapters/mobile/bridge-runtime/lib/config.cjs

@@ -4,9 +4,9 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 /** Read a value from .js.env */
-function loadEnvValue(key) {
+function loadEnvValue(key, appRoot = process.env.APP_ROOT || process.cwd()) {
   try {
-    const envPath = path.resolve(process.env.APP_ROOT || process.cwd(), '.js.env');
+    const envPath = path.resolve(appRoot, '.js.env');
     const content = fs.readFileSync(envPath, 'utf8');
     // .js.env uses `export KEY="value"` (shell-sourceable format),
     // so we handle the optional `export` prefix and strip surrounding quotes.
@@ -18,9 +18,19 @@ function loadEnvValue(key) {
   return undefined;
 }
 
+function resolvePort(env = process.env, appRoot = env.APP_ROOT || process.cwd()) {
+  return (
+    env.WATCHER_PORT ||
+    env.METRO_PORT ||
+    loadEnvValue('WATCHER_PORT', appRoot) ||
+    loadEnvValue('METRO_PORT', appRoot) ||
+    '8081'
+  );
+}
+
 /** Read WATCHER_PORT from .js.env or env (default: 8081) */
 function loadPort() {
-  return Number.parseInt(process.env.WATCHER_PORT || loadEnvValue('WATCHER_PORT') || '8081', 10);
+  return Number.parseInt(resolvePort(), 10);
 }
 
 /** Read IOS_SIMULATOR name from .js.env or env (default: none — accept any device) */
@@ -48,4 +58,4 @@ function loadAndroidTargetDeviceName() {
   return process.env.ANDROID_TARGET_DEVICE_NAME || '';
 }
 
-module.exports = { loadEnvValue, loadPort, loadSimulatorName, loadAndroidDevice, loadAndroidTargetDeviceName };
+module.exports = { loadEnvValue, loadPort, resolvePort, loadSimulatorName, loadAndroidDevice, loadAndroidTargetDeviceName };

package/adapters/mobile/start-console-forwarder.sh

@@ -3,7 +3,7 @@
 set -uo pipefail
 
 TARGET="$PWD"
-PORT="${WATCHER_PORT:-${METRO_PORT:-8081}}"
+PORT="${WATCHER_PORT:-${METRO_PORT:-}}"
 QUIET=false
 
 while [ "$#" -gt 0 ]; do
@@ -22,6 +22,10 @@ done
 [ "${METAMASK_RECIPE_CONSOLE_FORWARD:-1}" != "0" ] || exit 0
 TARGET="$(cd "$TARGET" && pwd -P)"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -z "$PORT" ] && command -v node >/dev/null 2>&1; then
+  PORT="$(APP_ROOT="$TARGET" CONFIG_PATH="$SCRIPT_DIR/bridge-runtime/lib/config.cjs" node -e "process.stdout.write(String(require(process.env.CONFIG_PATH).resolvePort()))")"
+fi
+PORT="${PORT:-8081}"
 # shellcheck disable=SC1091
 . "$SCRIPT_DIR/../shared/harness-path.sh"
 LOG_DIR="$TARGET/$(recipe_runtime_dir)" || exit 1