@deeeed/metamask-harness 0.79.0 → 0.80.0

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

@@ -1,110 +0,0 @@
-'use strict';
-
-/**
- * Evaluate a JS expression in the app's Hermes runtime via CDP Runtime.evaluate.
- * Returns the evaluated value (primitives and JSON-serialisable objects).
- */
-async function cdpEval(client, expression) {
-  // Hermes doesn't support async in Runtime.evaluate, use a plain IIFE
-  const wrapped = `(function() { return (${expression}); })()`;
-  const result = await client.send('Runtime.evaluate', {
-    expression: wrapped,
-    returnByValue: true,
-    awaitPromise: false,
-    generatePreview: false,
-  });
-
-  if (result.exceptionDetails) {
-    const desc =
-      result.exceptionDetails.exception?.description ||
-      result.exceptionDetails.text ||
-      JSON.stringify(result.exceptionDetails);
-    throw new Error(`Evaluation error: ${desc}`);
-  }
-
-  return result.result?.value;
-}
-
-/**
- * Evaluate a JS expression that returns a Promise.
- * Hermes CDP doesn't support awaitPromise, so we store the result on
- * globalThis.__cdp_async__ and poll for it.
- */
-async function cdpEvalAsync(client, expression, timeoutMs = cdpMessageTimeout()) {
-  // Unique key per call to avoid collisions
-  const key = `__cdp_async_${Date.now()}_${Math.random().toString(36).slice(2)}__`;
-
-  // Kick off the promise, store result when done.
-  // The try/catch guards against synchronous throws during argument evaluation
-  // of Promise.resolve(<expression>) — without it, a sync error escapes the
-  // IIFE and globalThis[key] stays 'pending' forever.
-  const kickoff = `(function() {
-    globalThis['${key}'] = { status: 'pending' };
-    try {
-      Promise.resolve(${expression})
-        .then(function(v) { globalThis['${key}'] = { status: 'resolved', value: v }; })
-        .catch(function(e) { globalThis['${key}'] = { status: 'rejected', error: String(e) }; });
-    } catch(e) {
-      globalThis['${key}'] = { status: 'rejected', error: String(e) };
-    }
-    return 'started';
-  })()`;
-
-  const kickoffResult = await client.send('Runtime.evaluate', {
-    expression: kickoff,
-    returnByValue: true,
-    awaitPromise: false,
-  }, timeoutMs);
-
-  // If the IIFE itself failed to evaluate (syntax error, etc.), bail early
-  if (kickoffResult.exceptionDetails) {
-    const desc =
-      kickoffResult.exceptionDetails.exception?.description ||
-      kickoffResult.exceptionDetails.text ||
-      JSON.stringify(kickoffResult.exceptionDetails);
-    throw new Error(`Async evaluation error: ${desc}`);
-  }
-
-  // Best-effort cleanup — swallow errors so a disconnected WebSocket
-  // doesn't obscure the actual result or diagnostic error.
-  const cleanup = () =>
-    client
-      .send('Runtime.evaluate', {
-        expression: `delete globalThis['${key}']`,
-        returnByValue: true,
-        awaitPromise: false,
-      })
-      // eslint-disable-next-line no-empty-function
-      .catch(() => {});
-
-  // Poll for completion
-  const pollInterval = 200;
-  const deadline = Date.now() + timeoutMs;
-  try {
-    while (Date.now() < deadline) {
-      await new Promise((r) => setTimeout(r, pollInterval));
-      const check = await client.send('Runtime.evaluate', {
-        expression: `(function() { return globalThis['${key}']; })()`,
-        returnByValue: true,
-        awaitPromise: false,
-      }, timeoutMs);
-      const val = check.result?.value;
-      if (val?.status === 'resolved') {
-        return val.value;
-      }
-      if (val?.status === 'rejected') {
-        throw new Error(`Async evaluation error: ${val.error}`);
-      }
-    }
-    throw new Error(`Async evaluation timed out after ${timeoutMs}ms`);
-  } finally {
-    await cleanup();
-  }
-}
-
-function cdpMessageTimeout() {
-  const timeoutMs = Number.parseInt(process.env.CDP_TIMEOUT || '30000', 10);
-  return Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 30000;
-}
-
-module.exports = { cdpEval, cdpEvalAsync };

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

@@ -1,61 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-/** Read a value from .js.env */
-function loadEnvValue(key, appRoot = process.env.APP_ROOT || process.cwd()) {
-  try {
-    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.
-    const match = content.match(new RegExp(String.raw`^(?:export\s+)?${key}=(.+)$`, 'm'));
-    if (match) return match[1].trim().replace(/^["']/, '').replace(/["']$/, '');
-  } catch {
-    // .js.env may not exist — fall through to undefined
-  }
-  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(resolvePort(), 10);
-}
-
-/** Read IOS_SIMULATOR name from .js.env or env (default: none — accept any device) */
-function loadSimulatorName() {
-  // Explicit empty string in env means "no simulator" — don't fall through to .js.env
-  if ('IOS_SIMULATOR' in process.env) return process.env.IOS_SIMULATOR;
-  return loadEnvValue('IOS_SIMULATOR') || '';
-}
-
-/** Read ANDROID_DEVICE from .js.env or env (default: none — accept any device) */
-function loadAndroidDevice() {
-  if ('ANDROID_DEVICE' in process.env) return process.env.ANDROID_DEVICE;
-  return loadEnvValue('ANDROID_DEVICE') || '';
-}
-
-/**
- * Read ANDROID_TARGET_DEVICE_NAME from env — the Metro-compatible model prefix
- * resolved from an adb serial by bridge.mjs. Used by target-discovery to select
- * the correct Metro CDP target when multiple devices are connected.
- *
- * Set automatically by the bridge when --device <serial> is used. Users never
- * need to set this; pass --device <adb-serial> and the harness maps it internally.
- */
-function loadAndroidTargetDeviceName() {
-  return process.env.ANDROID_TARGET_DEVICE_NAME || '';
-}
-
-module.exports = { loadEnvValue, loadPort, resolvePort, loadSimulatorName, loadAndroidDevice, loadAndroidTargetDeviceName };

package/adapters/mobile/bridge-runtime/lib/console-format.cjs

@@ -1,53 +0,0 @@
-'use strict';
-
-// Render CDP Runtime.consoleAPICalled args (RemoteObjects) into a log line.
-// Primitives carry `value`; objects/arrays do not — a bare console.log(obj)
-// arrived as the literal "Object". Hermes ships an inline `preview` (the same
-// one React Native DevTools renders in its console), so objects expand from it
-// synchronously — no extra CDP round-trip, so the stream never blocks. Depth is
-// bounded because previews nest one level via `valuePreview`; beyond that the
-// child preview's own description is used.
-
-const MAX_PREVIEW_DEPTH = 2;
-
-function formatPropertyValue(prop, depth) {
-  if (prop.valuePreview && depth < MAX_PREVIEW_DEPTH) {
-    return formatPreview(prop.valuePreview, depth + 1);
-  }
-  if (prop.type === 'string' && prop.value !== undefined) return JSON.stringify(prop.value);
-  if (prop.value !== undefined) return String(prop.value);
-  return prop.subtype || prop.type || '';
-}
-
-function formatPreview(preview, depth) {
-  const properties = Array.isArray(preview.properties) ? preview.properties : [];
-  const overflow = preview.overflow ? ', …' : '';
-  if (preview.subtype === 'array') {
-    return `[${properties.map((p) => formatPropertyValue(p, depth)).join(', ')}${overflow}]`;
-  }
-  const body = properties.map((p) => `${p.name}: ${formatPropertyValue(p, depth)}`).join(', ');
-  // Name a non-plain constructor (Error, Map, custom class) so the class is not lost.
-  const ctor = preview.description && preview.description !== 'Object' ? `${preview.description} ` : '';
-  return properties.length > 0 || overflow ? `${ctor}{ ${body}${overflow} }` : `${ctor}{}`;
-}
-
-function formatRemoteObject(a) {
-  if (!a || typeof a !== 'object') return String(a == null ? '' : a);
-  // Primitives (number/boolean/string) carry a directly-usable value.
-  if (a.type !== 'object' && a.type !== 'function' && a.value !== undefined) return String(a.value);
-  if (a.type === 'undefined') return 'undefined';
-  if (a.subtype === 'null') return 'null';
-  if (a.preview) return formatPreview(a.preview, 1);
-  // Functions, errors, and objects with no preview: the description is the best
-  // available text (className / Error stack / etc.); fall back to bare value/type.
-  if (a.description !== undefined) return a.description;
-  if (a.value !== undefined) return String(a.value);
-  return a.type || '';
-}
-
-function formatArgs(args, maxLineChars) {
-  const text = (args || []).map(formatRemoteObject).join(' ');
-  return maxLineChars && text.length > maxLineChars ? `${text.slice(0, maxLineChars)}…` : text;
-}
-
-module.exports = { formatArgs, formatRemoteObject, formatPreview };

package/adapters/mobile/bridge-runtime/lib/devtools-proxy.cjs

@@ -1,177 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const { WebSocket, WebSocketServer } = require('ws');
-
-const MAX_FRAME_BYTES = 8 * 1024 * 1024;
-const SESSION_TIMEOUT_MS = 10_000;
-const EVENT_GATED_DOMAINS = new Set([
-  'Debugger',
-  'Log',
-  'Network',
-  'Page',
-  'ReactNativeApplication',
-  'Runtime',
-]);
-
-function createDevtoolsProxy({
-  descriptorPath,
-  sessions,
-  sendCommand,
-  requestDiscovery,
-  allowedOrigins,
-}) {
-  if (!Array.isArray(allowedOrigins) || allowedOrigins.length === 0) {
-    throw new Error('DevTools proxy requires at least one allowed Origin');
-  }
-  let listeningPort = null;
-  const clients = new Set();
-  const server = new WebSocketServer({
-    host: '127.0.0.1',
-    port: 0,
-    maxPayload: MAX_FRAME_BYTES,
-  });
-
-  async function waitForSession(deviceId) {
-    const ready = sessions.get(deviceId);
-    if (ready?.brokerReady) return ready;
-    requestDiscovery();
-    const deadline = Date.now() + SESSION_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      const session = sessions.get(deviceId);
-      if (session?.brokerReady) return session;
-    }
-    throw new Error('Hermes runtime is unavailable or reloading; retry the command');
-  }
-
-  function writeDescriptor() {
-    if (!listeningPort) return;
-    fs.writeFileSync(
-      descriptorPath,
-      `${JSON.stringify({ schemaVersion: 1, pid: process.pid, port: listeningPort })}\n`,
-      { mode: 0o600 },
-    );
-  }
-
-  async function forward(client, message) {
-    if (
-      !message ||
-      typeof message !== 'object' ||
-      !Number.isInteger(message.id) ||
-      typeof message.method !== 'string'
-    ) {
-      return;
-    }
-    if (message.method.endsWith('.disable')) {
-      client.enabled.delete(message.method.replace(/\.disable$/u, '.enable'));
-      if (client.socket.readyState === WebSocket.OPEN) {
-        client.socket.send(JSON.stringify({ id: message.id, result: {} }));
-      }
-      return;
-    }
-    const isEnable = message.method.endsWith('.enable');
-    if (isEnable) {
-      client.enabled.set(message.method, message.params || {});
-    }
-    try {
-      const session = await waitForSession(client.deviceId);
-      const result = await sendCommand(
-        session,
-        message.method,
-        message.params || {},
-        SESSION_TIMEOUT_MS,
-      );
-      if (client.socket.readyState === WebSocket.OPEN) {
-        client.socket.send(JSON.stringify({ id: message.id, result }));
-      }
-    } catch (error) {
-      if (isEnable) client.enabled.delete(message.method);
-      if (client.socket.readyState === WebSocket.OPEN) {
-        client.socket.send(
-          JSON.stringify({
-            id: message.id,
-            error: {
-              code: -32000,
-              message: String(error?.message || error).slice(0, 256),
-            },
-          }),
-        );
-      }
-    }
-  }
-
-  server.on('connection', (socket, request) => {
-    const url = new URL(request.url || '/', 'http://127.0.0.1');
-    const deviceId = url.searchParams.get('device');
-    if (
-      !deviceId ||
-      !allowedOrigins.includes(request.headers.origin)
-    ) {
-      socket.close(1008, 'invalid DevTools proxy Origin or device');
-      return;
-    }
-    for (const client of clients) {
-      if (client.deviceId === deviceId) {
-        client.socket.close(1000, 'replaced by a newer DevTools window');
-      }
-    }
-    const client = { socket, deviceId, enabled: new Map() };
-    clients.add(client);
-    socket.on('message', (data) => {
-      let message;
-      try {
-        message = JSON.parse(String(data));
-      } catch {
-        return;
-      }
-      void forward(client, message);
-    });
-    const drop = () => clients.delete(client);
-    socket.on('close', drop);
-    socket.on('error', drop);
-  });
-
-  server.on('listening', () => {
-    const address = server.address();
-    if (!address || typeof address === 'string') return;
-    listeningPort = address.port;
-    writeDescriptor();
-  });
-
-  return {
-    onSessionOpen(deviceId, session) {
-      for (const client of clients) {
-        if (client.deviceId !== deviceId) continue;
-        for (const [method, params] of client.enabled) {
-          void sendCommand(session, method, params, SESSION_TIMEOUT_MS).catch(
-            () => undefined,
-          );
-        }
-      }
-    },
-    onCdpEvent(deviceId, method, params) {
-      const payload = JSON.stringify({ method, params });
-      const domain = method.split('.', 1)[0];
-      for (const client of clients) {
-        if (
-          client.deviceId === deviceId &&
-          client.socket.readyState === WebSocket.OPEN &&
-          (!EVENT_GATED_DOMAINS.has(domain) ||
-            client.enabled.has(`${domain}.enable`))
-        ) {
-          client.socket.send(payload);
-        }
-      }
-    },
-    close() {
-      for (const client of clients) client.socket.close();
-      server.close();
-      try {
-        fs.unlinkSync(descriptorPath);
-      } catch {}
-    },
-  };
-}
-
-module.exports = { createDevtoolsProxy };