@deeeed/metamask-harness 0.79.0 → 0.81.0

package/dist/network-observation.js

@@ -1,290 +0,0 @@
-import path from "node:path";
-import brokerModule from "../adapters/mobile/bridge-runtime/lib/cdp-broker.cjs";
-import configModule from "../adapters/mobile/bridge-runtime/lib/config.cjs";
-import {
-  createExtensionNetworkObserver
-} from "./adapters/extension/network-observer.js";
-import { getAdapterSurface } from "./adapters/surface.js";
-import {
-  indexArtifactManifest,
-  writeContainedArtifact
-} from "./artifact-files.js";
-const AUTO_CAPTURE_ID = "run-network";
-const AUTO_ARTIFACT_PATH = "network/run-summary.json";
-const { brokerSocketPath, createBrokerClient } = brokerModule;
-const { resolvePort } = configModule;
-const sessions = /* @__PURE__ */ new Map();
-async function startRunNetworkObservation(adapter, target, artifactsDir, env, ports = {}) {
-  const network = getAdapterSurface(adapter).observation?.network;
-  if (!network) return void 0;
-  const runtimeEnv = {
-    ...env,
-    ...ports.cdpPort ? { CDP_PORT: ports.cdpPort, RECIPE_CDP_PORT: ports.cdpPort } : {},
-    ...ports.watcherPort ? { WATCHER_PORT: ports.watcherPort } : {}
-  };
-  const key = path.resolve(artifactsDir);
-  const session = {
-    artifactsDir: key,
-    autoStarted: false,
-    autoStartedAt: Date.now(),
-    nodeEvents: []
-  };
-  sessions.set(key, session);
-  try {
-    session.backend = await network.backend(target, runtimeEnv, key);
-  } catch (error) {
-    session.setupError = boundedError(error);
-  }
-  if (runtimeEnv.MM_HARNESS_AUTO_NETWORK_CAPTURE !== "0") {
-    session.autoStartedAt = Date.now();
-    if (session.backend) {
-      try {
-        await session.backend.start({
-          id: AUTO_CAPTURE_ID,
-          bodyJsonFields: ["type"],
-          maxDurationMs: 60 * 60 * 1e3,
-          maxRequests: 1e4,
-          methods: [],
-          urlIncludes: []
-        });
-        session.autoStarted = true;
-      } catch (error) {
-        session.setupError = boundedError(error);
-      }
-    }
-  }
-  return {
-    onActionEvent(event) {
-      session.nodeEvents.push({ ...event, epochMs: Date.now() });
-    },
-    async finalize(artifactManifestPath) {
-      try {
-        if (runtimeEnv.MM_HARNESS_AUTO_NETWORK_CAPTURE !== "0") {
-          const summary = await automaticSummary(session);
-          await writeSummary(key, AUTO_ARTIFACT_PATH, summary);
-          if (artifactManifestPath) {
-            await indexArtifact(
-              artifactManifestPath,
-              AUTO_ARTIFACT_PATH,
-              "Automatic network observation"
-            );
-          }
-        }
-      } finally {
-        sessions.delete(key);
-        await session.backend?.close();
-      }
-    }
-  };
-}
-async function handleRunNetworkAction(platform, action, node, context) {
-  if (!getAdapterSurface(platform).observation?.network?.actions) return null;
-  if (action === "app.network_assert") {
-    const assertion = await import("../library/actions/shared/app/network-assert.mjs");
-    return {
-      output: await assertion.assertNetwork({ action, node, context })
-    };
-  }
-  if (action !== "app.network_capture") return null;
-  const phase = String(node.phase ?? "").toLowerCase();
-  const id = String(node.id ?? "").trim();
-  if (!["start", "end"].includes(phase) || !id) {
-    throw new Error(
-      "app.network_capture requires phase=start|end and a non-empty id."
-    );
-  }
-  const session = sessions.get(path.resolve(context.artifactsDir));
-  if (!session?.backend) {
-    throw new Error(
-      `Extension network observation is unavailable: ${session?.setupError ?? "run observer was not started"}.`
-    );
-  }
-  if (phase === "start") {
-    const result = await session.backend.start(captureParams(id, node));
-    return {
-      output: {
-        action,
-        phase,
-        ...asRecord(result)
-      }
-    };
-  }
-  const artifactPath = String(
-    node.artifact_path ?? `network/${id}-summary.json`
-  );
-  const summary = await session.backend.end(id);
-  await writeSummary(context.artifactsDir, artifactPath, summary);
-  return {
-    output: {
-      action,
-      phase,
-      ...summary
-    },
-    artifacts: [
-      {
-        path: artifactPath,
-        type: "report",
-        nodeId: context.nodeId
-      }
-    ]
-  };
-}
-async function createMobileNetworkBackend(target, env) {
-  const { client } = await connectMobileBroker(target, env);
-  return {
-    start(params) {
-      return client.control("capture-start", params, 1e4);
-    },
-    async end(id) {
-      return asRecord(await client.control("capture-end", { id }, 1e4));
-    },
-    async close() {
-      client.close();
-    }
-  };
-}
-async function connectMobileBroker(target, env) {
-  const runtimeDir = env.RECIPE_RUNTIME_DIR ? path.resolve(target, env.RECIPE_RUNTIME_DIR) : path.join(target, "temp", "recipe", "runtime");
-  const socketPath = brokerSocketPath(
-    runtimeDir,
-    resolvePort(env, target)
-  );
-  const discoveryClient = await createBrokerClient(socketPath, "", 1e4);
-  let targets;
-  try {
-    targets = await discoveryClient.control(
-      "resolve-targets",
-      { nameIncludes: mobileTargetPin(env) },
-      1e4
-    );
-  } finally {
-    discoveryClient.close();
-  }
-  const deviceId = selectMobileBrokerTarget(targets, env);
-  const client = await createBrokerClient(socketPath, deviceId, 1e4);
-  return { client, deviceId };
-}
-function selectMobileBrokerTarget(value, env) {
-  const targets = Array.isArray(value) ? value.map(asRecord).filter((target) => target.deviceId) : [];
-  const pin = mobileTargetPin(env);
-  const candidates = pin ? targets.filter(
-    (target) => String(target.name ?? "").toLowerCase().includes(pin.toLowerCase())
-  ) : targets;
-  if (candidates.length !== 1) {
-    throw new Error(
-      `Mobile network observation requires one broker target; found ${candidates.length}.`
-    );
-  }
-  return String(candidates[0].deviceId);
-}
-function mobileTargetPin(env) {
-  const platform = String(
-    env.MM_HARNESS_EXPLICIT_PLATFORM ?? env.RECIPE_HARNESS_PLATFORM ?? ""
-  ).toLowerCase();
-  return String(
-    platform === "android" ? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? "" : platform === "ios" ? env.IOS_SIMULATOR ?? "" : env.IOS_SIMULATOR ?? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? ""
-  ).trim();
-}
-async function automaticSummary(session) {
-  let summary;
-  if (session.autoStarted && session.backend) {
-    try {
-      summary = await session.backend.end(AUTO_CAPTURE_ID);
-    } catch (error) {
-      summary = unavailableSummary(session.autoStartedAt, boundedError(error));
-    }
-  } else {
-    summary = unavailableSummary(
-      session.autoStartedAt,
-      session.setupError ?? "Network observer did not start."
-    );
-  }
-  const startedAt = Number(summary.startedAtEpochMs ?? session.autoStartedAt);
-  return {
-    ...summary,
-    nodeEvents: session.nodeEvents.map((event) => ({
-      action: event.action,
-      elapsedMs: Math.max(0, event.epochMs - startedAt),
-      nodeId: event.nodeId,
-      status: event.status
-    }))
-  };
-}
-function unavailableSummary(startedAtEpochMs, reason) {
-  return {
-    schemaVersion: 1,
-    id: AUTO_CAPTURE_ID,
-    status: "unavailable",
-    startedAtEpochMs,
-    endedAtEpochMs: Date.now(),
-    maxDurationMs: 60 * 60 * 1e3,
-    reconnects: 0,
-    droppedRequests: 0,
-    unavailableReasons: [reason],
-    coverageGapReasons: [],
-    uninspectableBodyRequests: 0,
-    projectedBodyFields: ["type"],
-    totalRequests: 0,
-    requestsByMethod: {},
-    requestsByHost: {},
-    requestsByType: {},
-    requests: []
-  };
-}
-function captureParams(id, node) {
-  return {
-    id,
-    urlIncludes: node.url_includes ?? [],
-    methods: node.methods ?? [],
-    bodyJsonFields: node.body_json_fields ?? [],
-    maxRequests: node.max_requests,
-    maxDurationMs: node.max_duration_ms
-  };
-}
-async function writeSummary(artifactsDir, relativePath, summary) {
-  await writeContainedArtifact(
-    artifactsDir,
-    relativePath,
-    `${JSON.stringify(summary, null, 2)}
-`,
-    "Network artifact"
-  );
-}
-async function indexArtifact(artifactManifestPath, relativePath, label) {
-  await indexArtifactManifest(
-    artifactManifestPath,
-    [
-      {
-        path: relativePath,
-        type: "report",
-        label,
-        category: "diagnostic"
-      }
-    ]
-  );
-}
-async function createExtensionNetworkBackend(env, artifactsDir) {
-  return createExtensionNetworkObserver(extensionCdpPort(env), artifactsDir);
-}
-function extensionCdpPort(env) {
-  const port = Number(
-    env.CDP_PORT ?? env.RECIPE_CDP_PORT ?? process.env.CDP_PORT
-  );
-  if (!Number.isInteger(port) || port <= 0) {
-    throw new Error("Extension network observation requires CDP_PORT.");
-  }
-  return port;
-}
-function boundedError(error) {
-  return String(error instanceof Error ? error.message : error).slice(0, 256);
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-export {
-  connectMobileBroker,
-  createExtensionNetworkBackend,
-  createMobileNetworkBackend,
-  handleRunNetworkAction,
-  startRunNetworkObservation
-};

package/dist/recording-target.js

@@ -1,120 +0,0 @@
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-const ANDROID_RECORDING_TARGET_PREFIX = "android-device:";
-const IOS_SIMULATOR_RECORDING_TARGET_PREFIX = "ios-simulator:";
-function createMetaMaskRecordingTargetProvider(adapter) {
-  return {
-    async resolveRecordingTarget(context) {
-      const { getAdapterSurface } = await import("./adapters/surface.js");
-      const recording = getAdapterSurface(adapter).recording;
-      if (!recording) throw new Error(`--record-video is not implemented for the ${adapter} adapter.`);
-      return recording.target(context);
-    }
-  };
-}
-function resolveAndroidDeviceSerial(env = process.env) {
-  return env.ADB_SERIAL?.trim() || process.env.ADB_SERIAL?.trim() || void 0;
-}
-function captureHelperSupportsRecordSessionSnapshots(projectRoot) {
-  return captureHelperSupportsCapability(projectRoot, "record_session_snapshot");
-}
-function captureHelperSupportsCapability(projectRoot, capability) {
-  const result = spawnSync(captureHelperPath(), ["version", "--json"], {
-    cwd: projectRoot,
-    encoding: "utf8"
-  });
-  if (result.status !== 0) return false;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    return Array.isArray(parsed.capabilities) && parsed.capabilities.includes(capability);
-  } catch {
-    return false;
-  }
-}
-function resolveMobileIosSimulatorName(env = process.env) {
-  const explicit = env.IOS_SIMULATOR?.trim() || env.SIM_UDID?.trim();
-  if (explicit) return explicit;
-  const slot = env.FARMSLOT_SLOT_ID?.trim() || env.SLOT_ID?.trim();
-  if (!slot) return void 0;
-  const suffix = slot.includes("-") ? slot.slice(slot.lastIndexOf("-") + 1) : slot;
-  return suffix || void 0;
-}
-function resolveMobileIosSimulatorPid(simulator) {
-  const result = spawnSync(
-    captureHelperPath(),
-    ["resolve", "--app-name", "Simulator", "--window-name", simulator, "--json"],
-    { encoding: "utf8" }
-  );
-  if (result.status !== 0) return null;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    return parsePositivePid(parsed.selected?.pid);
-  } catch {
-    return null;
-  }
-}
-function resolveExtensionBrowserPid(projectRoot, artifactsDir, cdpPort) {
-  const explicit = parsePositivePid(process.env.METAMASK_RECIPE_EXTENSION_BROWSER_PID);
-  if (explicit) return explicit;
-  if (cdpPort) {
-    const lsof = spawnSync("lsof", ["-nP", `-iTCP:${cdpPort}`, "-sTCP:LISTEN", "-t"], {
-      cwd: projectRoot,
-      encoding: "utf8"
-    });
-    if (lsof.status === 0) {
-      const pid = parsePositivePid(String(lsof.stdout).split(/\s+/u).find(Boolean));
-      if (pid) return pid;
-    }
-  }
-  for (const file of [
-    path.join(artifactsDir, "extension-runtime/runtime.json"),
-    path.join(projectRoot, "temp/recipe/runtime/runtime.json")
-  ]) {
-    const pid = parsePositivePid(readJsonFile(file)?.pid);
-    if (pid) return pid;
-  }
-  for (const file of [
-    path.join(projectRoot, "temp/recipe/runtime/chromium.pid"),
-    path.join(projectRoot, "temp/recipe/runtime/browser.pid")
-  ]) {
-    const pid = parsePositivePid(readTextFile(file));
-    if (pid) return pid;
-  }
-  return null;
-}
-function captureHelperPath() {
-  return process.env.CAPTURE_HELPER_PATH || "capture-helper";
-}
-function parsePositivePid(value) {
-  const pid = Number(String(value ?? "").trim());
-  return Number.isInteger(pid) && pid > 0 ? pid : null;
-}
-function readJsonFile(file) {
-  if (!fs.existsSync(file)) return null;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function readTextFile(file) {
-  if (!fs.existsSync(file)) return "";
-  try {
-    return fs.readFileSync(file, "utf8");
-  } catch {
-    return "";
-  }
-}
-export {
-  ANDROID_RECORDING_TARGET_PREFIX,
-  IOS_SIMULATOR_RECORDING_TARGET_PREFIX,
-  captureHelperSupportsCapability,
-  captureHelperSupportsRecordSessionSnapshots,
-  createMetaMaskRecordingTargetProvider,
-  resolveAndroidDeviceSerial,
-  resolveExtensionBrowserPid,
-  resolveMobileIosSimulatorName,
-  resolveMobileIosSimulatorPid
-};