@deeeed/metamask-harness 0.73.0 → 0.75.0

package/dist/adapters/performance/cdp-trace.js

@@ -18,6 +18,22 @@ const EXTENSION_TRACE_CATEGORIES = [
   "disabled-by-default-devtools.timeline.frame",
   "v8.execute"
 ];
+const MOBILE_TRACE_KIND = {
+  categories: MOBILE_TRACE_CATEGORIES,
+  rendererScoped: false,
+  nativeSource: "react-native-cdp-frame-timings",
+  javascriptTasks: false
+};
+const TRACE_KINDS = {
+  extension: {
+    categories: EXTENSION_TRACE_CATEGORIES,
+    rendererScoped: true,
+    nativeSource: "chromium-cdp-frame-timings",
+    javascriptTasks: true
+  },
+  ios: MOBILE_TRACE_KIND,
+  android: MOBILE_TRACE_KIND
+};
 function createCdpTraceCollector(client, platform, marker) {
   let active;
   const offData = client.on("Tracing.dataCollected", (params) => {
@@ -60,7 +76,7 @@ function createCdpTraceCollector(client, platform, marker) {
         await client.send(
           "Tracing.start",
           {
-            categories: (platform === "extension" ? EXTENSION_TRACE_CATEGORIES : MOBILE_TRACE_CATEGORIES).join(","),
+            categories: TRACE_KINDS[platform].categories.join(","),
             transferMode: "ReportEvents"
           },
           15e3
@@ -126,7 +142,8 @@ function createCdpTraceCollector(client, platform, marker) {
 }
 function parseTraceCapture(capture) {
   const marker = findClockMarker(capture.events, capture.markerName);
-  if (capture.platform === "extension" && !finite(marker?.pid)) {
+  const kind = TRACE_KINDS[capture.platform];
+  if (kind.rendererScoped && !finite(marker?.pid)) {
     const reason = "Extension trace marker did not identify a renderer process.";
     return {
       platform: capture.platform,
@@ -135,12 +152,12 @@ function parseTraceCapture(capture) {
       trace: traceEvidence(capture, "unresolved")
     };
   }
-  const scopedEvents = capture.platform === "extension" && finite(marker?.pid) ? capture.events.filter((event) => event.pid === marker.pid) : capture.events;
-  const scope = capture.platform !== "extension" ? "mobile-host" : finite(marker?.pid) ? "extension-renderer" : "unresolved";
+  const scopedEvents = kind.rendererScoped && finite(marker?.pid) ? capture.events.filter((event) => event.pid === marker.pid) : capture.events;
+  const scope = !kind.rendererScoped ? "mobile-host" : finite(marker?.pid) ? "extension-renderer" : "unresolved";
   const trace = traceEvidence(
     { ...capture, events: scopedEvents },
     scope,
-    capture.platform === "extension" && finite(marker?.pid) ? marker.pid : void 0
+    kind.rendererScoped && finite(marker?.pid) ? marker.pid : void 0
   );
   if (!finite(marker?.ts) || capture.markerHostEpochMs === void 0 || capture.markerUncertaintyMs === void 0) {
     const reason = "CDP trace clock marker was unavailable.";
@@ -181,7 +198,7 @@ function parseTraceCapture(capture) {
       capture.markerUncertaintyMs
     ),
     nativeUi: nativeUiSourceResult(
-      capture.platform === "extension" ? "chromium-cdp-frame-timings" : "react-native-cdp-frame-timings",
+      kind.nativeSource,
       nativeSamples,
       status,
       gapReasons,
@@ -383,6 +400,7 @@ function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 export {
+  TRACE_KINDS,
   createCdpTraceCollector,
   parseTraceCapture
 };

package/dist/adapters/performance/device-platform.js

@@ -0,0 +1,10 @@
+function devicePlatformFromEnv(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 {
+  devicePlatformFromEnv
+};

package/dist/adapters/registry.js

@@ -0,0 +1,17 @@
+const surfaces = /* @__PURE__ */ new Map();
+const adapterRegistry = {
+  register(surface) {
+    if (surfaces.has(surface.adapter)) throw new Error(`adapter '${surface.adapter}' is already registered`);
+    surfaces.set(surface.adapter, surface);
+  },
+  get(id) {
+    const surface = surfaces.get(id);
+    if (!surface) throw new Error(`unknown adapter '${id}' (registered: ${adapterRegistry.list().join(", ")})`);
+    return surface;
+  },
+  has: (id) => surfaces.has(id),
+  list: () => [...surfaces.keys()]
+};
+export {
+  adapterRegistry
+};

package/dist/adapters/surface.js

@@ -1,15 +1,10 @@
-import { coreSurface } from "./core/surface.js";
-import { extensionSurface } from "./extension/surface.js";
-import { mobileSurface } from "./mobile/surface.js";
-import { terminalSurface } from "./terminal/surface.js";
-const SURFACES = {
-  mobile: mobileSurface,
-  extension: extensionSurface,
-  core: coreSurface,
-  terminal: terminalSurface
-};
+import { adapterRegistry } from "./registry.js";
+import "./mobile/surface.js";
+import "./extension/surface.js";
+import "./core/surface.js";
+import "./terminal/surface.js";
 function getAdapterSurface(adapter) {
-  return SURFACES[adapter];
+  return adapterRegistry.get(adapter);
 }
 export {
   getAdapterSurface

package/dist/adapters/terminal/actions.js

@@ -0,0 +1,43 @@
+import { manifestPath } from "../../paths.js";
+const terminalActions = {
+  manifestPath: () => manifestPath("terminal"),
+  semantic: [
+    "app.network_capture",
+    "app.network_assert",
+    "app.performance_capture",
+    "app.performance_assert"
+  ],
+  cdpTarget: { transport: "chrome-cdp", probePath: "json/version" },
+  ui: (harness, { hudPolicy }) => ({
+    base: harness.createCdpWebUiTransport({
+      async withPage(input, callback) {
+        const { withTerminalPage } = await import("../../../library/actions/terminal/platform/page.mjs");
+        return withTerminalPage(
+          {
+            action: input.action,
+            node: input.node,
+            context: {
+              nodeId: input.context.nodeId,
+              projectRoot: input.context.projectRoot,
+              artifactsDir: input.context.artifactsDir
+            }
+          },
+          callback
+        );
+      }
+    }),
+    async execute(action, node, context, standard) {
+      if (action === "app.hud") {
+        const { showTerminalHud } = await import("../../../library/actions/terminal/platform/hud.mjs");
+        return showTerminalHud(
+          { action, node, context: { nodeId: context.nodeId, projectRoot: context.projectRoot } },
+          { hudPolicy }
+        );
+      }
+      return standard();
+    }
+  })
+};
+export {
+  terminalActions
+};

package/dist/adapters/terminal/console-capture.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { verifyCapture } from "../../../library/actions/shared/console-collector.mjs";
 import { recipeRuntimePath } from "../../paths.js";
 import { ensureConsoleCollector } from "../console-capture.js";
 const TERMINAL_CONSOLE_FILES = Object.freeze({
@@ -37,10 +38,22 @@ async function ensureTerminalConsoleCapture(target) {
     cwd: target
   });
 }
+async function verifyTerminalConsoleControl(capture) {
+  let browser = null;
+  try {
+    const value = JSON.parse(fs.readFileSync(terminalRuntimeFile(capture.projectRoot, "browser.json"), "utf8"));
+    browser = typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    browser = null;
+  }
+  if (typeof browser?.appOrigin !== "string") return { ok: false, detail: "no slot browser state (browser.json) to verify the page console capture against" };
+  return verifyCapture({ cdpPort: capture.cdpPort, log: capture.pageLog, target: "page", appOrigin: browser.appOrigin });
+}
 export {
   TERMINAL_CONSOLE_FILES,
   ensureTerminalConsoleCapture,
   terminalCaptureFiles,
   terminalCdpPort,
-  terminalRuntimeFile
+  terminalRuntimeFile,
+  verifyTerminalConsoleControl
 };

package/dist/adapters/terminal/launch.js

@@ -0,0 +1,85 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { flag, str } from "../../commands/shared.js";
+import { runnerDir } from "../../paths.js";
+const TERMINAL_ONLY_LAUNCH_OPTIONS = Object.freeze({
+  signer: "--signer",
+  account: "--account",
+  freshProfile: "--fresh-profile",
+  headless: "--headless",
+  headful: "--headful",
+  slowMo: "--slow-mo",
+  network: "--network",
+  mainnetConfirmation: "--mainnet-confirmation"
+});
+function terminalOnlyLaunchFlags(options) {
+  return Object.entries(TERMINAL_ONLY_LAUNCH_OPTIONS).filter(([key]) => options[key] !== void 0 && options[key] !== false).map(([, name]) => name);
+}
+function parseTerminalLauncherOutput(output) {
+  const text = output.trim();
+  if (!text) return { status: "fail", error: "the terminal launcher printed no summary" };
+  try {
+    return JSON.parse(text);
+  } catch {
+    const last = text.split("\n").filter((line) => line.trim()).pop() ?? "";
+    try {
+      return JSON.parse(last);
+    } catch {
+      return { status: "fail", error: `the terminal launcher printed no JSON summary: ${last.slice(0, 200)}` };
+    }
+  }
+}
+async function launchTerminal({ options, target, jsonOutput, stream, usage }) {
+  const cdpPort = str(options, "cdpPort") ?? process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT;
+  const appPort = str(options, "watcherPort") ?? process.env.TERMINAL_APP_PORT ?? process.env.RECIPE_WATCHER_PORT ?? process.env.WATCHER_PORT;
+  if (!cdpPort || !appPort) {
+    return usage(
+      "terminal launch needs the slot browser CDP port and the slot dev-server port.",
+      "mm-harness launch --adapter terminal --cdp-port <port> --watcher-port <app port>"
+    );
+  }
+  const args = [
+    path.join(runnerDir, "adapters", "terminal", "launch.mjs"),
+    "--target",
+    target,
+    "--cdp-port",
+    cdpPort,
+    "--app-port",
+    appPort,
+    "--signer",
+    str(options, "signer") ?? process.env.TERMINAL_SIGNER ?? "extension",
+    "--account",
+    str(options, "account") ?? process.env.TERMINAL_ACCOUNT ?? "dev1",
+    "--json"
+  ];
+  if (flag(options, "freshProfile")) args.push("--fresh-profile");
+  if (flag(options, "headless")) args.push("--headless");
+  if (flag(options, "headful")) args.push("--headful");
+  const slowMo = str(options, "slowMo");
+  if (slowMo) args.push("--slow-mo", slowMo);
+  const network = str(options, "network");
+  if (network) args.push("--network", network);
+  const mainnetConfirmation = str(options, "mainnetConfirmation");
+  if (mainnetConfirmation) args.push("--mainnet-confirmation", mainnetConfirmation);
+  stream.phase("launch", { adapter: "terminal", cdpPort, appPort });
+  let output = "";
+  let status = 0;
+  try {
+    output = execFileSync(process.execPath, args, { encoding: "utf8", stdio: ["ignore", "pipe", "inherit"] });
+  } catch (error) {
+    status = 1;
+    output = String(error.stdout ?? "");
+  }
+  const result = parseTerminalLauncherOutput(output);
+  if (jsonOutput) console.log(JSON.stringify({ schemaVersion: 1, command: "launch", adapter: "terminal", target, ...result }, null, 2));
+  else if (result.status === "pass") console.log(`\u2713 terminal browser ${result.reused ? "reused" : "started"} on CDP ${result.cdpPort} (${result.signer}, ${result.account?.name})`);
+  else console.error(`\u2717 terminal launch failed: ${result.error ?? "unknown error"}`);
+  stream.complete(result.status === "pass" ? "pass" : "fail", status);
+  return result.status === "pass" ? 0 : 1;
+}
+export {
+  TERMINAL_ONLY_LAUNCH_OPTIONS,
+  launchTerminal,
+  parseTerminalLauncherOutput,
+  terminalOnlyLaunchFlags
+};

package/dist/adapters/terminal/run.js

@@ -0,0 +1,30 @@
+import { devicePlatformFromEnv } from "../performance/device-platform.js";
+import {
+  ensureTerminalConsoleCapture,
+  terminalCaptureFiles,
+  terminalCdpPort,
+  terminalRuntimeFile,
+  verifyTerminalConsoleControl
+} from "./console-capture.js";
+const terminalDiagnostics = {
+  console: {
+    start: (projectRoot) => ensureTerminalConsoleCapture(projectRoot),
+    files: (projectRoot) => terminalCaptureFiles(projectRoot),
+    cdpPort: () => terminalCdpPort(),
+    verifyControl: (capture) => verifyTerminalConsoleControl(capture)
+  },
+  walletLog: (projectRoot) => terminalRuntimeFile(projectRoot, "wallet-requests.jsonl")
+};
+const terminalObservation = {
+  network: {
+    backend: async (_target, env, artifactsDir) => (await import("../../network-observation.js")).createExtensionNetworkBackend(env, artifactsDir)
+  },
+  performance: {
+    backend: async (target, env, ports) => (await import("../../performance-observation.js")).createExtensionPerformanceObserver(target, env, ports),
+    platform: (env) => devicePlatformFromEnv(env)
+  }
+};
+export {
+  terminalDiagnostics,
+  terminalObservation
+};

package/dist/adapters/terminal/surface.js

@@ -3,6 +3,9 @@ import { shellQuote } from "../../commands/parse-args.js";
 import fs from "node:fs";
 import { TERMINAL_CONSOLE_FILES, terminalRuntimeFile } from "./console-capture.js";
 import { stopTerminalBrowserSync } from "./stop.js";
+import { adapterRegistry } from "../registry.js";
+import { terminalActions } from "./actions.js";
+import { terminalDiagnostics, terminalObservation } from "./run.js";
 function portFromEnv(...names) {
   for (const name of names) {
     const raw = process.env[name];
@@ -95,8 +98,13 @@ const terminalSurface = {
     launch: "mm-harness launch --adapter terminal --cdp-port <port> --watcher-port <app port>",
     relaunch: "mm-harness launch --adapter terminal --fresh-profile",
     runtimeProbeRecovery: (target) => `mm-harness doctor --adapter terminal --target ${shellQuote(path.resolve(target))}`
-  }
+  },
+  launch: async (context) => (await import("./launch.js")).launchTerminal(context),
+  actions: terminalActions,
+  diagnostics: terminalDiagnostics,
+  observation: terminalObservation
 };
+adapterRegistry.register(terminalSurface);
 export {
   terminalAppPort,
   terminalCdpPort,