@deeeed/metamask-harness 0.2.0

package/library/actions/mobile/bridge-runtime/lib/target-discovery.cjs

@@ -0,0 +1,204 @@
+'use strict';
+
+const http = require('node:http');
+const { loadSimulatorName, loadAndroidDevice } = require('./config.cjs');
+const { createWSClient } = require('./ws-client.cjs');
+
+const FETCH_TIMEOUT_MS = Number.parseInt(process.env.CDP_TIMEOUT || '30000', 10);
+const FETCH_RETRIES = Number.parseInt(process.env.CDP_DISCOVERY_RETRIES || '3', 10);
+
+/** Fetch JSON from a URL (http only, no external deps) */
+function fetchJSONOnce(url) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, (res) => {
+      let data = '';
+      res.on('data', (chunk) => (data += chunk));
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`Failed to parse JSON from ${url}: ${e.message}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.setTimeout(FETCH_TIMEOUT_MS, () => {
+      req.destroy();
+      reject(new Error(`Timeout fetching ${url} after ${FETCH_TIMEOUT_MS}ms`));
+    });
+  });
+}
+
+async function fetchJSON(url) {
+  let lastError;
+  for (let attempt = 1; attempt <= FETCH_RETRIES; attempt++) {
+    try {
+      return await fetchJSONOnce(url);
+    } catch (error) {
+      lastError = error;
+      if (attempt === FETCH_RETRIES) break;
+      await new Promise((resolve) => setTimeout(resolve, attempt * 1000));
+    }
+  }
+  throw lastError;
+}
+
+/**
+ * Quick probe: connect to a CDP target, evaluate `__DEV__`, disconnect.
+ * Returns true if __AGENTIC__ is installed, false otherwise.
+ */
+async function probeTarget(wsUrl) {
+  try {
+    const client = await createWSClient(wsUrl, 3000);
+    try {
+      const result = await client.send('Runtime.evaluate', {
+        expression: '(function(){ return typeof globalThis.__AGENTIC__; })()',
+        returnByValue: true,
+        awaitPromise: false,
+      });
+      return result?.result?.value === 'object';
+    } finally {
+      client.close();
+    }
+  } catch {
+    // Connection failed — target is not the right one
+    return false;
+  }
+}
+
+/**
+ * Discover the Hermes CDP WebSocket URL from Metro's /json/list endpoint.
+ *
+ * Multi-simulator support:
+ *   - When IOS_SIMULATOR is set, filters targets by deviceName
+ *   - With Hermes bridgeless mode, there are multiple pages per device:
+ *     page 1 = native C++ runtime, page 2+ = JS runtime (where __AGENTIC__ lives)
+ *   - We probe candidates to find the one with __AGENTIC__ installed
+ */
+async function discoverTarget(port) {
+  const listUrl = `http://localhost:${port}/json/list`;
+  let targets;
+  try {
+    targets = await fetchJSON(listUrl);
+  } catch (e) {
+    throw new Error(
+      `Cannot reach Metro at ${listUrl}. Is Metro running?\n  ${e.message}`,
+    );
+  }
+
+  if (!Array.isArray(targets) || targets.length === 0) {
+    throw new Error(`No debug targets found at ${listUrl}`);
+  }
+
+  // Filter to React Native / Hermes targets with a WebSocket URL
+  let candidates = targets.filter(
+    (t) =>
+      t.webSocketDebuggerUrl &&
+      // Pre-RN-0.81 titles say "React Native"/"Hermes". RN 0.81+ Bridgeless
+      // titles are bundle-id-only (e.g. "io.metamask.MetaMask (mm-5)") and
+      // the runtime kind is in `description` instead.
+      ((t.title &&
+        (/react/i.test(t.title) || /hermes/i.test(t.title))) ||
+        /bridgeless|hermes/i.test(t.description || '')),
+  );
+
+  // Filter by device name if IOS_SIMULATOR is set
+  const simName = loadSimulatorName();
+  if (simName && candidates.length > 1) {
+    const deviceFiltered = candidates.filter(
+      (t) => t.deviceName === simName,
+    );
+    if (deviceFiltered.length > 0) {
+      candidates = deviceFiltered;
+    }
+  }
+
+  // Filter by device name if ANDROID_DEVICE is set
+  const androidDevice = loadAndroidDevice();
+  if (androidDevice && candidates.length > 1) {
+    const deviceFiltered = candidates.filter(
+      (t) => t.deviceName === androidDevice,
+    );
+    if (deviceFiltered.length > 0) {
+      candidates = deviceFiltered;
+    }
+  }
+
+  if (candidates.length === 0) {
+    candidates = targets.filter((t) => t.webSocketDebuggerUrl);
+  }
+
+  if (candidates.length === 0) {
+    throw new Error(
+      `No suitable debug target found. Targets:\n${JSON.stringify(targets, null, 2)}`,
+    );
+  }
+
+  // Sort by page number descending (JS runtime has higher page number than C++ native)
+  candidates.sort((a, b) => {
+    const aPage = Number.parseInt((a.id || '').split('-').pop() || '0', 10);
+    const bPage = Number.parseInt((b.id || '').split('-').pop() || '0', 10);
+    return bPage - aPage;
+  });
+
+  // Probe candidates to find the one with __AGENTIC__ installed (the JS runtime)
+  for (const candidate of candidates) {
+    const hasAgentic = await probeTarget(candidate.webSocketDebuggerUrl);
+    if (hasAgentic) {
+      return { wsUrl: candidate.webSocketDebuggerUrl, deviceName: candidate.deviceName || '' };
+    }
+  }
+
+  // Fallback: return highest page number (most likely the JS runtime)
+  return { wsUrl: candidates[0].webSocketDebuggerUrl, deviceName: candidates[0].deviceName || '' };
+}
+
+/**
+ * Discover ALL Hermes targets with __AGENTIC__ installed (one per platform/device).
+ * Groups by deviceName so each device returns at most one target.
+ */
+async function discoverAllTargets(port) {
+  const listUrl = `http://localhost:${port}/json/list`;
+  let targets;
+  try {
+    targets = await fetchJSON(listUrl);
+  } catch (e) {
+    throw new Error(
+      `Cannot reach Metro at ${listUrl}. Is Metro running?\n  ${e.message}`,
+    );
+  }
+
+  const candidates = (targets || []).filter(
+    (t) =>
+      t.webSocketDebuggerUrl &&
+      // Pre-RN-0.81 titles say "React Native"/"Hermes". RN 0.81+ Bridgeless
+      // titles are bundle-id-only (e.g. "io.metamask.MetaMask (mm-5)") and
+      // the runtime kind is in `description` instead.
+      ((t.title &&
+        (/react/i.test(t.title) || /hermes/i.test(t.title))) ||
+        /bridgeless|hermes/i.test(t.description || '')),
+  );
+
+  // Sort by page number descending (JS runtime has higher page number)
+  candidates.sort((a, b) => {
+    const aPage = Number.parseInt((a.id || '').split('-').pop() || '0', 10);
+    const bPage = Number.parseInt((b.id || '').split('-').pop() || '0', 10);
+    return bPage - aPage;
+  });
+
+  // Group by deviceName, probe each to find the JS runtime target
+  const seen = new Set();
+  const results = [];
+  for (const candidate of candidates) {
+    const device = candidate.deviceName || candidate.id || candidate.webSocketDebuggerUrl;
+    if (seen.has(device)) continue;
+    const hasAgentic = await probeTarget(candidate.webSocketDebuggerUrl);
+    if (hasAgentic) {
+      seen.add(device);
+      results.push({ wsUrl: candidate.webSocketDebuggerUrl, deviceName: device });
+    }
+  }
+  return results;
+}
+
+module.exports = { discoverTarget, discoverAllTargets };

package/library/actions/mobile/bridge-runtime/lib/ws-client.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+/* global globalThis */
+
+/**
+ * Minimal CDP client using the built-in ws-like interface over raw WebSocket.
+ * Node 22+ has a built-in WebSocket; for older versions we use the ws package
+ * that ships with React Native / Metro dev dependencies.
+ */
+function createWSClient(wsUrl, timeout) {
+  return new Promise((resolve, reject) => {
+    let WebSocketImpl;
+    // Node 22+ has globalThis.WebSocket
+    if (typeof globalThis.WebSocket === 'function') {
+      WebSocketImpl = globalThis.WebSocket;
+    } else {
+      try {
+        // Dynamic require avoids depcheck static analysis — ws is an optional
+        // fallback for Node < 22 which has no built-in WebSocket.
+        const wsModule = 'ws';
+        WebSocketImpl = require(wsModule);
+      } catch {
+        throw new Error(
+          'WebSocket not available. Install "ws" package or use Node >= 22.',
+        );
+      }
+    }
+
+    const ws = new WebSocketImpl(wsUrl);
+    let msgId = 0;
+    const pending = new Map();
+
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error(`CDP connection timeout after ${timeout}ms`));
+    }, timeout);
+
+    ws.onopen = () => {
+      clearTimeout(timer);
+      resolve({
+        /** Send a CDP command and wait for the response */
+        send(method, params = {}, msgTimeout = timeout) {
+          return new Promise((res, rej) => {
+            const id = ++msgId;
+            const timer = setTimeout(() => {
+              pending.delete(id);
+              rej(
+                new Error(
+                  `CDP message timeout after ${msgTimeout}ms for ${method}`,
+                ),
+              );
+            }, msgTimeout);
+            pending.set(id, {
+              resolve: (v) => {
+                clearTimeout(timer);
+                res(v);
+              },
+              reject: (e) => {
+                clearTimeout(timer);
+                rej(e);
+              },
+            });
+            const msg = JSON.stringify({ id, method, params });
+            ws.send(msg);
+          });
+        },
+        close() {
+          ws.close();
+        },
+      });
+    };
+
+    ws.onmessage = (evt) => {
+      const data = typeof evt.data === 'string' ? evt.data : evt.data.toString();
+      let msg;
+      try {
+        msg = JSON.parse(data);
+      } catch {
+        // Non-JSON frame — ignore
+        return;
+      }
+      if (msg.id && pending.has(msg.id)) {
+        const { resolve: res, reject: rej } = pending.get(msg.id);
+        pending.delete(msg.id);
+        if (msg.error) {
+          rej(new Error(`CDP error: ${JSON.stringify(msg.error)}`));
+        } else {
+          res(msg.result);
+        }
+      }
+    };
+
+    ws.onerror = (err) => {
+      clearTimeout(timer);
+      reject(new Error(`WebSocket error: ${err.message || err}`));
+    };
+
+    ws.onclose = () => {
+      clearTimeout(timer);
+      for (const [, { reject: rej }] of pending) {
+        rej(new Error('WebSocket closed'));
+      }
+      pending.clear();
+    };
+  });
+}
+
+module.exports = { createWSClient };