@deeeed/metamask-harness 0.42.0 → 0.43.0

package/dist/adapters/extension/browser-cdp.js

@@ -0,0 +1,174 @@
+import { WebSocket } from "ws";
+import { withTimeout } from "../../async.js";
+const DEFAULT_TIMEOUT_MS = 1e4;
+async function createBrowserCdpClient(cdpPort) {
+  if (!Number.isInteger(cdpPort) || cdpPort <= 0) {
+    throw new Error("Extension CDP requires a valid port.");
+  }
+  const version = asRecord(
+    await fetchJson(`http://127.0.0.1:${cdpPort}/json/version`)
+  );
+  const webSocketUrl = String(version.webSocketDebuggerUrl ?? "");
+  if (!webSocketUrl) {
+    throw new Error("Extension browser CDP WebSocket is unavailable.");
+  }
+  const socket = new WebSocket(webSocketUrl);
+  await waitForOpen(socket);
+  let nextId = 0;
+  const pending = /* @__PURE__ */ new Map();
+  const handlers = /* @__PURE__ */ new Set();
+  const closeHandlers = /* @__PURE__ */ new Set();
+  socket.on("message", (data) => {
+    let message;
+    try {
+      message = JSON.parse(String(data));
+    } catch {
+      return;
+    }
+    if (message.id && pending.has(message.id)) {
+      const command = pending.get(message.id);
+      pending.delete(message.id);
+      if (!command) return;
+      clearTimeout(command.timer);
+      if (message.error) {
+        command.reject(
+          new Error(
+            String(message.error.message ?? "Extension CDP command failed")
+          )
+        );
+      } else {
+        command.resolve(message.result ?? {});
+      }
+      return;
+    }
+    for (const handler of handlers) handler(message);
+  });
+  socket.on("close", () => {
+    for (const command of pending.values()) {
+      clearTimeout(command.timer);
+      command.reject(new Error("Extension browser CDP connection closed"));
+    }
+    pending.clear();
+    handlers.clear();
+    for (const handler of closeHandlers) handler();
+    closeHandlers.clear();
+  });
+  return {
+    send(method, params = {}, sessionId, timeoutMs = DEFAULT_TIMEOUT_MS) {
+      return new Promise((resolve, reject) => {
+        const id = ++nextId;
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`Extension CDP command timed out: ${method}`));
+        }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+        socket.send(
+          JSON.stringify({
+            id,
+            method,
+            params,
+            ...sessionId ? { sessionId } : {}
+          })
+        );
+      });
+    },
+    onMessage(handler) {
+      handlers.add(handler);
+      return () => handlers.delete(handler);
+    },
+    onClose(handler) {
+      closeHandlers.add(handler);
+      return () => closeHandlers.delete(handler);
+    },
+    close() {
+      socket.close();
+    }
+  };
+}
+async function fetchCdpJson(cdpPort, path = "/json") {
+  return fetchJson(`http://127.0.0.1:${cdpPort}${path}`);
+}
+function asBrowserCdpTarget(value) {
+  const target = asRecord(value);
+  const targetId = String(target.targetId ?? target.id ?? "");
+  const type = String(target.type ?? "");
+  const url = String(target.url ?? "");
+  return targetId && type && url ? { targetId, type, url } : null;
+}
+function extensionIdFromCdpTargets(value) {
+  const targets = Array.isArray(value) ? value : [];
+  for (const candidate of targets) {
+    const target = asBrowserCdpTarget(candidate);
+    if (!target) continue;
+    try {
+      const url = new URL(target.url);
+      if (url.protocol === "chrome-extension:" && url.hostname) {
+        return url.hostname;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function selectExtensionUiTarget(value, extensionId) {
+  const targets = Array.isArray(value) ? value : [];
+  const candidates = targets.map(asBrowserCdpTarget).filter((candidate) => {
+    if (!candidate || !["page", "other"].includes(candidate.type)) return false;
+    try {
+      const url = new URL(candidate.url);
+      return url.protocol === "chrome-extension:" && url.hostname === extensionId;
+    } catch {
+      return false;
+    }
+  });
+  const matchingPath = (target, pathname) => {
+    try {
+      return new URL(target.url).pathname === pathname;
+    } catch {
+      return false;
+    }
+  };
+  const home = candidates.filter((target) => matchingPath(target, "/home.html"));
+  if (home.length > 0) return home.length === 1 ? home[0] : null;
+  const sidepanel = candidates.filter(
+    (target) => matchingPath(target, "/sidepanel.html")
+  );
+  return sidepanel.length === 1 ? sidepanel[0] : null;
+}
+async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Extension CDP returned HTTP ${response.status}.`);
+  }
+  return response.json();
+}
+function waitForOpen(socket) {
+  const onOpen = (resolve) => () => resolve();
+  let openHandler;
+  let errorHandler;
+  const opened = new Promise((resolve, reject) => {
+    openHandler = onOpen(resolve);
+    errorHandler = reject;
+    socket.once("open", openHandler);
+    socket.once("error", errorHandler);
+  });
+  return withTimeout(opened, {
+    message: "Extension browser CDP connection timed out.",
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    onTimeout: () => socket.close()
+  }).finally(() => {
+    if (openHandler) socket.off("open", openHandler);
+    if (errorHandler) socket.off("error", errorHandler);
+  });
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export {
+  asBrowserCdpTarget,
+  createBrowserCdpClient,
+  extensionIdFromCdpTargets,
+  fetchCdpJson,
+  selectExtensionUiTarget
+};

package/dist/adapters/extension/network-observer.js

@@ -1,6 +1,11 @@
 import path from "node:path";
-import { WebSocket } from "ws";
 import brokerModule from "../../../adapters/mobile/bridge-runtime/lib/cdp-broker.cjs";
+import {
+  asBrowserCdpTarget,
+  createBrowserCdpClient,
+  extensionIdFromCdpTargets,
+  fetchCdpJson
+} from "./browser-cdp.js";
 const DEVICE_ID = "extension";
 const COMMAND_TIMEOUT_MS = 1e4;
 const EXTENSION_TARGET_TYPES = /* @__PURE__ */ new Set([
@@ -14,43 +19,19 @@ async function createExtensionNetworkObserver(cdpPort, runtimeDir) {
   if (!Number.isInteger(cdpPort) || cdpPort <= 0) {
     throw new Error("Extension network observation requires a valid CDP port.");
   }
-  const [version, targets] = await Promise.all([
-    fetchJson(`http://127.0.0.1:${cdpPort}/json/version`),
-    fetchJson(`http://127.0.0.1:${cdpPort}/json`)
-  ]);
-  const browserWebSocketUrl = String(
-    asRecord(version).webSocketDebuggerUrl ?? ""
-  );
-  const extensionId = extensionIdFromTargets(targets);
-  if (!browserWebSocketUrl || !extensionId) {
+  const targets = await fetchCdpJson(cdpPort);
+  const extensionId = extensionIdFromCdpTargets(targets);
+  if (!extensionId) {
     throw new Error(
       "Extension CDP browser or loaded extension target is unavailable."
     );
   }
-  const socket = new WebSocket(browserWebSocketUrl);
-  await waitForOpen(socket);
-  let nextId = 0;
+  const connection = await createBrowserCdpClient(cdpPort);
   let closed = false;
   const brokerRef = {};
-  const pending = /* @__PURE__ */ new Map();
   const targetSessions = /* @__PURE__ */ new Map();
   const attaching = /* @__PURE__ */ new Set();
-  const send = (method, params = {}, sessionId, timeoutMs = COMMAND_TIMEOUT_MS) => new Promise((resolve, reject) => {
-    const id = ++nextId;
-    const timer = setTimeout(() => {
-      pending.delete(id);
-      reject(new Error(`Extension CDP command timed out: ${method}`));
-    }, timeoutMs);
-    pending.set(id, { resolve, reject, timer });
-    socket.send(
-      JSON.stringify({
-        id,
-        method,
-        params,
-        ...sessionId ? { sessionId } : {}
-      })
-    );
-  });
+  const send = (method, params = {}, sessionId, timeoutMs = COMMAND_TIMEOUT_MS) => connection.send(method, params, sessionId, timeoutMs);
   const relevantTarget = (target) => {
     if (!EXTENSION_TARGET_TYPES.has(String(target.type))) return false;
     try {
@@ -89,36 +70,14 @@ async function createExtensionNetworkObserver(cdpPort, runtimeDir) {
       attaching.delete(target.targetId);
     }
   };
-  socket.on("message", (data) => {
-    let message;
-    try {
-      message = JSON.parse(String(data));
-    } catch {
-      return;
-    }
-    if (message.id && pending.has(message.id)) {
-      const command = pending.get(message.id);
-      pending.delete(message.id);
-      if (!command) return;
-      clearTimeout(command.timer);
-      if (message.error) {
-        command.reject(
-          new Error(
-            String(message.error.message ?? "Extension CDP command failed")
-          )
-        );
-      } else {
-        command.resolve(message.result ?? {});
-      }
-      return;
-    }
+  connection.onMessage((message) => {
     if (message.method === "Target.targetCreated") {
-      const target = asTargetInfo(message.params?.targetInfo);
+      const target = asBrowserCdpTarget(message.params?.targetInfo);
       if (target) void attachTarget(target);
       return;
     }
     if (message.method === "Target.attachedToTarget") {
-      const target = asTargetInfo(message.params?.targetInfo);
+      const target = asBrowserCdpTarget(message.params?.targetInfo);
       const sessionId = String(message.params?.sessionId ?? "");
       if (target && sessionId && relevantTarget(target)) {
         targetSessions.set(target.targetId, sessionId);
@@ -143,22 +102,17 @@ async function createExtensionNetworkObserver(cdpPort, runtimeDir) {
       );
     }
   });
-  socket.on("close", () => {
+  connection.onClose(() => {
     if (!closed) brokerRef.current?.onSessionClose(DEVICE_ID);
-    for (const command of pending.values()) {
-      clearTimeout(command.timer);
-      command.reject(new Error("Extension browser CDP connection closed"));
-    }
-    pending.clear();
   });
   await send("Target.setDiscoverTargets", { discover: true });
   const targetResult = asRecord(await send("Target.getTargets"));
   const targetInfos = Array.isArray(targetResult.targetInfos) ? targetResult.targetInfos : [];
   await Promise.all(
-    targetInfos.map(asTargetInfo).filter((target) => Boolean(target)).map(attachTarget)
+    targetInfos.map(asBrowserCdpTarget).filter((target) => Boolean(target)).map(attachTarget)
   );
   if (targetSessions.size === 0) {
-    socket.close();
+    connection.close();
     throw new Error("Extension CDP exposes no attachable extension targets.");
   }
   const sessions = /* @__PURE__ */ new Map([[DEVICE_ID, { brokerReady: true }]]);
@@ -208,7 +162,7 @@ async function createExtensionNetworkObserver(cdpPort, runtimeDir) {
         const infos = asRecord(result).targetInfos;
         if (!Array.isArray(infos)) return;
         for (const value of infos) {
-          const target = asTargetInfo(value);
+          const target = asBrowserCdpTarget(value);
           if (target) void attachTarget(target);
         }
       }).catch(() => brokerRef.current?.onSessionClose(DEVICE_ID));
@@ -234,58 +188,13 @@ async function createExtensionNetworkObserver(cdpPort, runtimeDir) {
       closed = true;
       client.close();
       brokerRef.current?.close();
-      socket.close();
+      connection.close();
     }
   };
 }
-async function fetchJson(url) {
-  const response = await fetch(url);
-  if (!response.ok)
-    throw new Error(`Extension CDP returned HTTP ${response.status}.`);
-  return response.json();
-}
-function extensionIdFromTargets(targets) {
-  const values = Array.isArray(targets) ? targets : [];
-  for (const target of values) {
-    const info = asTargetInfo(target);
-    if (!info) continue;
-    try {
-      const url = new URL(info.url);
-      if (url.protocol !== "chrome-extension:") continue;
-      const extensionId = url.hostname;
-      if (extensionId) return extensionId;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
 function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function asTargetInfo(value) {
-  const target = asRecord(value);
-  const targetId = String(target.targetId ?? target.id ?? "");
-  const type = String(target.type ?? "");
-  const url = String(target.url ?? "");
-  return targetId && type && url ? { targetId, type, url } : null;
-}
-function waitForOpen(socket) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      socket.close();
-      reject(new Error("Extension browser CDP connection timed out."));
-    }, COMMAND_TIMEOUT_MS);
-    socket.once("open", () => {
-      clearTimeout(timer);
-      resolve();
-    });
-    socket.once("error", (error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-  });
-}
 async function waitForSocket(socketPath) {
   const { existsSync } = await import("node:fs");
   const deadline = Date.now() + COMMAND_TIMEOUT_MS;

package/dist/adapters/extension/performance-observer.js

@@ -0,0 +1,75 @@
+import {
+  createCdpTraceCollector
+} from "../performance/cdp-trace.js";
+import {
+  createBrowserCdpClient,
+  fetchCdpJson,
+  selectExtensionUiTarget
+} from "./browser-cdp.js";
+import { resolveExtensionId } from "./extension-id.js";
+async function createExtensionPerformanceBackend(cdpPort, target) {
+  const extensionId = (await resolveExtensionId(target, { cdpPort })).extensionId;
+  if (!extensionId) {
+    throw new Error("Extension performance observation could not resolve the MetaMask extension id.");
+  }
+  const uiTarget = selectExtensionUiTarget(
+    await fetchCdpJson(cdpPort),
+    extensionId
+  );
+  if (!uiTarget) {
+    throw new Error("Extension performance observation requires an open MetaMask UI target.");
+  }
+  const browser = await createBrowserCdpClient(cdpPort);
+  const attached = asRecord(
+    await browser.send(
+      "Target.attachToTarget",
+      { targetId: uiTarget.targetId, flatten: true },
+      void 0,
+      1e4
+    )
+  );
+  const sessionId = String(attached.sessionId ?? "");
+  if (!sessionId) {
+    browser.close();
+    throw new Error("Extension performance observation could not attach to the MetaMask UI target.");
+  }
+  const client = browserTraceClient(browser);
+  return createCdpTraceCollector(client, "extension", async (name) => {
+    const before = Date.now();
+    await browser.send(
+      "Runtime.evaluate",
+      {
+        expression: `performance.mark(${JSON.stringify(name)})`,
+        returnByValue: true
+      },
+      sessionId,
+      1e4
+    );
+    const after = Date.now();
+    return {
+      hostEpochMs: (before + after) / 2,
+      uncertaintyMs: (after - before) / 2
+    };
+  });
+}
+function browserTraceClient(browser) {
+  return {
+    send(method, params = {}, timeoutMs) {
+      return browser.send(method, params, void 0, timeoutMs);
+    },
+    on(method, handler) {
+      return browser.onMessage((message) => {
+        if (message.method === method) handler(message.params ?? {});
+      });
+    },
+    close() {
+      browser.close();
+    }
+  };
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export {
+  createExtensionPerformanceBackend
+};

package/dist/adapters/mobile/frame-metrics.js

@@ -0,0 +1,45 @@
+function summarizeFrames(samples) {
+  const validSamples = samples.filter(
+    (sample) => Number.isFinite(sample.durationMs) && sample.durationMs > 0
+  );
+  const durations = validSamples.map((sample) => sample.durationMs).sort((first2, second) => first2 - second);
+  if (durations.length === 0) return { frameCount: 0 };
+  const jankValues = validSamples.map((sample) => sample.janky).filter((value) => value !== void 0);
+  const jankyFrameCount = jankValues.filter(Boolean).length;
+  const first = validSamples[0]?.completedAtEpochMs;
+  const last = validSamples.at(-1)?.completedAtEpochMs;
+  const elapsedMs = first !== void 0 && last !== void 0 && last > first ? last - first : void 0;
+  return {
+    ...elapsedMs ? {
+      averageFps: round(
+        (validSamples.length - 1) * 1e3 / elapsedMs
+      )
+    } : {},
+    frameCount: durations.length,
+    ...jankValues.length === validSamples.length ? {
+      jankyFrameCount,
+      jankyFramePercent: round(
+        jankyFrameCount / validSamples.length * 100
+      )
+    } : {},
+    longestFrameMs: round(durations.at(-1) ?? 0),
+    p50FrameMs: round(percentile(durations, 0.5)),
+    p95FrameMs: round(percentile(durations, 0.95)),
+    p99FrameMs: round(percentile(durations, 0.99))
+  };
+}
+function percentile(sorted, quantile) {
+  if (sorted.length === 1) return sorted[0] ?? 0;
+  const position = (sorted.length - 1) * quantile;
+  const lower = Math.floor(position);
+  const upper = Math.ceil(position);
+  const lowerValue = sorted[lower] ?? 0;
+  const upperValue = sorted[upper] ?? lowerValue;
+  return lowerValue + (upperValue - lowerValue) * (position - lower);
+}
+function round(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+export {
+  summarizeFrames
+};

package/dist/adapters/mobile/performance-observer.js

@@ -0,0 +1,43 @@
+import {
+  createCdpTraceCollector
+} from "../performance/cdp-trace.js";
+import {
+  connectMobileBroker
+} from "../../network-observation.js";
+async function createMobilePerformanceBackend(target, env) {
+  const { client } = await connectMobileBroker(target, env);
+  return createCdpTraceCollector(
+    client,
+    resolvePlatform(env),
+    async (name) => {
+      const before = Date.now();
+      await markRuntime(client, name);
+      const after = Date.now();
+      return {
+        hostEpochMs: (before + after) / 2,
+        uncertaintyMs: (after - before) / 2
+      };
+    }
+  );
+}
+async function markRuntime(client, name) {
+  await client.send(
+    "Runtime.evaluate",
+    {
+      expression: `performance.mark(${JSON.stringify(name)})`,
+      returnByValue: true,
+      awaitPromise: false
+    },
+    1e4
+  );
+}
+function resolvePlatform(env) {
+  const explicit = String(
+    env.MM_HARNESS_EXPLICIT_PLATFORM ?? env.RECIPE_HARNESS_PLATFORM ?? ""
+  ).toLowerCase();
+  if (explicit === "android" || explicit === "ios") return explicit;
+  return env.ADB_SERIAL || env.ANDROID_SERIAL || env.ANDROID_DEVICE ? "android" : "ios";
+}
+export {
+  createMobilePerformanceBackend
+};