@deeeed/metamask-harness 0.47.3 → 0.47.4

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.47.4 - 2026-09-05
+
+### Fixed
+
+- Verify Mobile reloads through execution-context replacement when React Native retains its Hermes target ID, and advance broker runtime identity on context reset for lifecycle readiness checks.
+
 ## 0.47.3 - 2026-09-05
 
 ### Fixed

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

@@ -862,6 +862,10 @@ function createCdpBroker({
       }
     },
     onCdpEvent(deviceId, method, params) {
+      if (method === 'Runtime.executionContextsCleared') {
+        const target = knownTargets.get(deviceId);
+        if (target) knownTargets.set(deviceId, { ...target, generation: target.generation + 1 });
+      }
       for (const socket of clients) {
         if (subscriptions.get(socket)?.has(`${deviceId}\u0000${method}`)) {
           writeMessage(socket, { type: 'event', deviceId, method, params });

package/adapters/mobile/reload-app.mjs

@@ -1,12 +1,54 @@
 #!/usr/bin/env node
 
 import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 import { createRequire } from 'node:module';
 import { resolveMobileToolPath } from '../../library/actions/mobile/platform/tool-paths.mjs';
 
 const require = createRequire(import.meta.url);
 const WebSocket = require('ws');
-const { discoverTarget } = require('./bridge-runtime/lib/target-discovery.cjs');
+const { discoverTarget, rankRuntimeCandidates } = require('./bridge-runtime/lib/target-discovery.cjs');
+const { brokerSocketPath, createBrokerClient, deviceIdFromUrl } = require('./bridge-runtime/lib/cdp-broker.cjs');
+const { createWSClient } = require('./bridge-runtime/lib/ws-client.cjs');
+
+async function observeRuntimeReset(port, target) {
+  const socketPath = brokerSocketPath(
+    process.env.RECIPE_RUNTIME_DIR || path.join(process.cwd(), 'temp/recipe/runtime'),
+    port,
+  );
+  const client = fs.existsSync(socketPath)
+    ? await createBrokerClient(socketPath, deviceIdFromUrl(target.wsUrl), 5000)
+    : await createWSClient(target.wsUrl, 5000);
+  let armed = false;
+  let cleared = false;
+  let recreated = false;
+  client.on('Runtime.executionContextsCleared', () => {
+    if (armed) cleared = true;
+  });
+  client.on('Runtime.executionContextCreated', () => {
+    if (armed && cleared) recreated = true;
+  });
+  try {
+    await client.send('Runtime.enable');
+    // Finish subscription/bootstrap before the reload request can generate events.
+    await client.send('Runtime.evaluate', { expression: 'true', returnByValue: true });
+    armed = true;
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+  return {
+    get recreated() { return recreated; },
+    async responsive(timeoutMs) {
+      const result = await client.send('Runtime.evaluate', {
+        expression: 'true', returnByValue: true,
+      }, timeoutMs);
+      return result?.result?.value === true;
+    },
+    close() { client.close(); },
+  };
+}
 
 function parseArgs(argv) {
   const args = {
@@ -46,30 +88,38 @@ async function reload(port) {
       'The Android Hermes sampling profiler is active, so a runtime reload can abort the app. Use an explicit app.lifecycle restart.',
     );
   }
-  await new Promise((resolve, reject) => {
-    const socket = new WebSocket(`ws://127.0.0.1:${numericPort}/message`);
-    const timeout = setTimeout(() => {
-      socket.close();
-      reject(new Error(`Metro reload timed out on port ${numericPort}`));
-    }, 5000);
-    socket.on('open', () => {
-      socket.send(JSON.stringify({ method: 'reload', version: 2 }));
-      setTimeout(() => {
-        clearTimeout(timeout);
+  const observer = await observeRuntimeReset(numericPort, targetBefore);
+  let verification;
+  try {
+    await new Promise((resolve, reject) => {
+      const socket = new WebSocket(`ws://127.0.0.1:${numericPort}/message`);
+      const timeout = setTimeout(() => {
         socket.close();
-        resolve();
-      }, 50);
-    });
-    socket.on('error', () => {
-      clearTimeout(timeout);
-      reject(new Error(`Metro is not reachable on port ${numericPort}`));
+        reject(new Error(`Metro reload timed out on port ${numericPort}`));
+      }, 5000);
+      socket.on('open', () => {
+        socket.send(JSON.stringify({ method: 'reload', version: 2 }));
+        setTimeout(() => {
+          clearTimeout(timeout);
+          socket.close();
+          resolve();
+        }, 50);
+      });
+      socket.on('error', () => {
+        clearTimeout(timeout);
+        reject(new Error(`Metro is not reachable on port ${numericPort}`));
+      });
     });
-  });
-  const targetAfter = await waitForReload(
-    numericPort,
-    targetBefore.id,
-    processBefore,
-  );
+    verification = await waitForReload(
+      numericPort,
+      targetBefore,
+      processBefore,
+      observer,
+    );
+  } finally {
+    observer.close();
+  }
+  const { target: targetAfter, proof } = verification;
   const processAfter = processBefore ? readAndroidPid() : null;
   if (processBefore && processAfter !== processBefore) {
     throw new Error(
@@ -84,6 +134,7 @@ async function reload(port) {
     port: numericPort,
     targetBefore: targetBefore.id,
     targetAfter: targetAfter.id,
+    verification: proof,
     ...(processBefore
       ? {
           processBefore,
@@ -94,20 +145,33 @@ async function reload(port) {
   };
 }
 
-async function waitForReload(port, targetBefore, processBefore) {
+async function waitForReload(port, targetBefore, processBefore, observer) {
   const deadline = Date.now() + 30_000;
+  let lastError;
   while (Date.now() < deadline) {
     if (processBefore && readAndroidPid() !== processBefore) {
       throw new Error(
         `Android app process ${processBefore} exited during reload. Inspect the native crash before using an explicit app.lifecycle restart.`,
       );
     }
-    const target = await readHermesTarget(port).catch(() => null);
-    if (target && target.id !== targetBefore) return target;
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/json/list`, {
+        signal: AbortSignal.timeout(Math.max(1, Math.min(1000, deadline - Date.now()))),
+      });
+      const targets = rankRuntimeCandidates(await response.json());
+      const target = targets.find((item) => item.deviceName === targetBefore.deviceName);
+      if (target && target.id !== targetBefore.id) return { target, proof: 'target-replaced' };
+      if (target && observer.recreated && await observer.responsive(Math.max(1, Math.min(1000, deadline - Date.now())))) {
+        return { target, proof: 'execution-context-recreated' };
+      }
+    } catch (error) {
+      // A reload temporarily removes the runtime; preserve the last failure if it never returns.
+      lastError = error;
+    }
     await new Promise((resolve) => setTimeout(resolve, 250));
   }
   throw new Error(
-    `React Native did not expose a new Hermes target after reload on port ${port}`,
+    `React Native reload was not verified on port ${port}: no target replacement or responsive new execution context${lastError ? ` (${lastError.message})` : ''}.\nNext: mm-harness status --json`,
   );
 }
 
@@ -155,7 +219,7 @@ const args = parseArgs(process.argv.slice(2));
 reload(args.port)
   .then((result) => {
     if (args.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-    else console.log(`Reload requested through Metro :${result.port}`);
+    else console.log(`Reload verified through Metro :${result.port} (${result.verification})`);
   })
   .catch((error) => {
     const result = { ok: false, adapter: 'mobile', error: String(error?.message || error) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.47.3",
+  "version": "0.47.4",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"