@deeeed/metamask-harness 0.74.0 → 0.76.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

@@ -6,7 +6,7 @@ const adapterRegistry = {
   },
   get(id) {
     const surface = surfaces.get(id);
-    if (!surface) throw new Error(`unknown adapter '${id}' (registered: ${[...surfaces.keys()].join(", ")})`);
+    if (!surface) throw new Error(`unknown adapter '${id}' (registered: ${adapterRegistry.list().join(", ")})`);
     return surface;
   },
   has: (id) => surfaces.has(id),

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/doctor-checks.js

@@ -0,0 +1,22 @@
+import { terminalAppPort, terminalCdpPort } from "./surface.js";
+async function terminalDoctorChecks(target) {
+  const { terminalReadiness } = await import("../../../adapters/terminal/lib/readiness.mjs");
+  const { resolveBrowser } = await import("../../../adapters/terminal/launch.mjs");
+  const report = await terminalReadiness({
+    target,
+    appPort: terminalAppPort(),
+    cdpPort: terminalCdpPort(),
+    signer: process.env.TERMINAL_SIGNER || "extension",
+    account: process.env.TERMINAL_ACCOUNT || "dev1",
+    probeBrowser: resolveBrowser
+  });
+  return report.checks.map((check) => ({
+    id: `terminal-${check.id}`,
+    status: check.status === "pass" ? "pass" : "fail",
+    required: check.required,
+    message: check.detail
+  }));
+}
+export {
+  terminalDoctorChecks
+};

package/dist/adapters/terminal/overlay.js

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { runnerDir } from "../../paths.js";
+const terminalHarness = {
+  install: { entry: "adapters/terminal/inject.mjs", fallback: "adapters/terminal/inject.mjs", node: true },
+  cleanup: { entry: "adapters/terminal/cleanup.mjs", fallback: "adapters/terminal/cleanup.mjs", node: true },
+  verify: () => ({ command: process.execPath, prefixArgs: [path.join(runnerDir, "adapters", "terminal", "verify.mjs")] }),
+  restart: "mm-harness launch"
+};
+const terminalRuntimeContext = {
+  forbiddenFields: ["metroPort", "simulator", "simulatorUdid", "adbSerial", "extensionId"],
+  resources: ({ existing, defaults, envPort }) => ({
+    cdpPort: envPort("RECIPE_CDP_PORT", "CDP_PORT") ?? existing.cdpPort ?? defaults.cdpPort
+  })
+};
+export {
+  terminalHarness,
+  terminalRuntimeContext
+};

package/dist/adapters/terminal/readiness.js

@@ -0,0 +1,11 @@
+import fs from "node:fs";
+import path from "node:path";
+const terminalReadiness = {
+  compatibilityMode: (target) => fs.existsSync(path.join(target, "src/features/perpetuals")) ? "slot browser over CDP (website; no product bridge)" : "unsupported/no bridge",
+  liveChecks: async (target) => (await import("./doctor-checks.js")).terminalDoctorChecks(target),
+  // Screenshots come from the slot browser over CDP.
+  captureProviders: ["cdp"]
+};
+export {
+  terminalReadiness
+};

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

@@ -4,6 +4,10 @@ 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 { terminalHarness, terminalRuntimeContext } from "./overlay.js";
+import { terminalReadiness } from "./readiness.js";
+import { terminalDiagnostics, terminalObservation } from "./run.js";
 function portFromEnv(...names) {
   for (const name of names) {
     const raw = process.env[name];
@@ -31,8 +35,8 @@ const terminalSurface = {
   resolveSlotPorts() {
   },
   async runtimeStatus(target) {
-    const { terminalReadiness } = await import("../../../adapters/terminal/lib/readiness.mjs");
-    const report = await terminalReadiness({
+    const { terminalReadiness: terminalReadiness2 } = await import("../../../adapters/terminal/lib/readiness.mjs");
+    const report = await terminalReadiness2({
       target: path.resolve(target),
       appPort: terminalAppPort(),
       cdpPort: terminalCdpPort(),
@@ -97,7 +101,21 @@ const terminalSurface = {
     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)
+  launch: async (context) => (await import("./launch.js")).launchTerminal(context),
+  actions: terminalActions,
+  harness: terminalHarness,
+  runtimeContext: terminalRuntimeContext,
+  readiness: terminalReadiness,
+  fixtures: { operations: ["init", "sync", "set"] },
+  debug: {
+    args: ({ devMenu }) => [
+      ...process.env.WATCHER_PORT ? ["--port", process.env.WATCHER_PORT] : [],
+      "--action",
+      devMenu ? "dev-menu" : "debug"
+    ]
+  },
+  diagnostics: terminalDiagnostics,
+  observation: terminalObservation
 };
 adapterRegistry.register(terminalSurface);
 export {