@deeeed/metamask-harness 0.74.0 → 0.76.0

package/dist/adapters/mobile/run.js

@@ -0,0 +1,156 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { isRecord } from "../../commands/parse-args.js";
+import { runnerDir } from "../../paths.js";
+import { devicePlatformFromEnv } from "../performance/device-platform.js";
+import {
+  IOS_SIMULATOR_RECORDING_TARGET_PREFIX,
+  resolveAndroidDeviceSerial,
+  resolveMobileIosSimulatorName
+} from "../../recording-target.js";
+import { requireCurrentMobileReleaseArtifactState } from "./release-artifact-state.js";
+const EXPLICIT_DEVICE_KEYS = [
+  "PLATFORM",
+  "MM_HARNESS_EXPLICIT_PLATFORM",
+  "IOS_SIMULATOR",
+  "SIM_UDID",
+  "ADB_SERIAL",
+  "ANDROID_SERIAL",
+  "ANDROID_DEVICE",
+  "ANDROID_TARGET_DEVICE_NAME"
+];
+const mobileRun = {
+  pinnedEnv() {
+    if (!process.env.MM_HARNESS_EXPLICIT_PLATFORM) return void 0;
+    return Object.fromEntries(EXPLICIT_DEVICE_KEYS.map((key) => [key, process.env[key]]));
+  },
+  envKeys: ["METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME", "ANDROID_PACKAGE_ID", "ADB_SERIAL", "ANDROID_SERIAL"],
+  activateEnv(projectRoot) {
+    const state = requireCurrentMobileReleaseArtifactState(projectRoot);
+    if (!state) return;
+    const selected = process.env.ADB_SERIAL ?? process.env.ANDROID_SERIAL;
+    if (selected && selected !== state.deviceSerial) {
+      throw new Error(
+        `The Mobile release artifact is installed on ${state.deviceSerial}, not ${selected}. Next: rerun runtime-launch for ${selected}.`
+      );
+    }
+    process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME = "1";
+    process.env.ANDROID_PACKAGE_ID = state.packageId;
+    process.env.ADB_SERIAL = state.deviceSerial;
+    process.env.ANDROID_SERIAL = state.deviceSerial;
+  },
+  childEnv: (base) => ({
+    ...base,
+    WATCHER_PORT: process.env.WATCHER_PORT ?? base.CDP_PORT ?? base.RECIPE_CDP_PORT,
+    METRO_PORT: process.env.METRO_PORT ?? process.env.WATCHER_PORT ?? base.CDP_PORT ?? base.RECIPE_CDP_PORT,
+    IOS_SIMULATOR: process.env.IOS_SIMULATOR,
+    SIM_UDID: process.env.SIM_UDID,
+    ANDROID_DEVICE: process.env.ANDROID_DEVICE,
+    ANDROID_TARGET_DEVICE_NAME: process.env.ANDROID_TARGET_DEVICE_NAME,
+    ADB_SERIAL: process.env.ADB_SERIAL,
+    ANDROID_SERIAL: process.env.ANDROID_SERIAL,
+    ANDROID_PACKAGE_ID: process.env.ANDROID_PACKAGE_ID,
+    METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME: process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME
+  }),
+  // An installed release artifact is opaque: no harness HUD inside it.
+  autoHud: () => process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME !== "1",
+  // Always clear a HUD step the engine left on-device (a failed run strands
+  // the FAIL banner). Best-effort — never masks the run's real outcome.
+  async teardown(projectRoot, env) {
+    const { hideMobileHudOnTeardown } = await import("./ui.js");
+    await hideMobileHudOnTeardown(projectRoot, env);
+  },
+  // A release artifact is checked before the overlay install; the loaded
+  // source only matters for a development build the caller did not restart.
+  runtimeCheck({ target, heal, state, json, appRestartAuthored }) {
+    if (requireCurrentMobileReleaseArtifactState(target) !== null || appRestartAuthored) return void 0;
+    return async () => {
+      const { ensureMobileProofRuntime } = await import("../../commands/run-engine.js");
+      return ensureMobileProofRuntime(target, heal, state, json);
+    };
+  }
+};
+const mobileRecording = {
+  target: (context) => resolveMobileRecordingTarget(context),
+  // An Android device records through the mirror, with screenrecord as the
+  // fallback; otherwise the selected iOS simulator records.
+  async videoRecorder() {
+    const androidSerial = resolveAndroidDeviceSerial();
+    const iosSimulator = androidSerial ? void 0 : resolveMobileIosSimulatorName();
+    if (!androidSerial && !iosSimulator) return void 0;
+    const { createAndroidVideoRecorder, createIosSimulatorVideoRecorder } = await import("./video-recorder.js");
+    if (androidSerial) {
+      const { createAndroidMirrorVideoRecorder } = await import("@farmslot/recipe-harness");
+      return createAndroidMirrorVideoRecorder({ serial: androidSerial, fallback: createAndroidVideoRecorder(androidSerial) });
+    }
+    return createIosSimulatorVideoRecorder(iosSimulator);
+  }
+};
+async function resolveMobileRecordingTarget(context) {
+  const platform = (context.env.PLATFORM ?? process.env.PLATFORM ?? "ios").trim().toLowerCase();
+  const androidSerial = resolveAndroidDeviceSerial(context.env);
+  if (platform === "android" || androidSerial) {
+    if (!androidSerial) {
+      throw new Error(
+        "Could not resolve an Android device for --record-video. Set ADB_SERIAL or pass --device to mm-harness run."
+      );
+    }
+    return {
+      kind: "android-device",
+      serial: androidSerial
+    };
+  }
+  const simulator = resolveMobileIosSimulatorName(context.env);
+  if (!simulator) {
+    throw new Error(
+      "Could not resolve an iOS simulator name for --record-video. Set IOS_SIMULATOR or pass --simulator to the recipe hook."
+    );
+  }
+  return {
+    kind: "window-id",
+    windowId: `${IOS_SIMULATOR_RECORDING_TARGET_PREFIX}${simulator}`
+  };
+}
+const mobileDiagnostics = {
+  issueBuffer: {
+    arm(projectRoot) {
+      if (process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === "1") return false;
+      if (!runMobileIssueCommand(projectRoot, "issues-arm")) return false;
+      return runMobileIssueCommand(projectRoot, "issues-collect") !== null;
+    },
+    collect(projectRoot) {
+      const result = runMobileIssueCommand(projectRoot, "issues-collect");
+      return isRecord(result) && Array.isArray(result.entries) ? result.entries : null;
+    }
+  }
+};
+const mobileObservation = {
+  network: {
+    backend: async (target, env) => (await import("../../network-observation.js")).createMobileNetworkBackend(target, env)
+  },
+  performance: {
+    backend: async (target, env) => (await import("./performance-observer.js")).createMobilePerformanceBackend(target, env),
+    platform: (env) => devicePlatformFromEnv(env)
+  }
+};
+function runMobileIssueCommand(projectRoot, command) {
+  const bridge = path.join(runnerDir, "adapters", "mobile", "bridge-runtime", "cdp-bridge.cjs");
+  const result = spawnSync(process.execPath, [bridge, command], {
+    cwd: projectRoot,
+    env: { ...process.env, APP_ROOT: projectRoot, CDP_TIMEOUT: "5000" },
+    encoding: "utf8",
+    timeout: 1e4
+  });
+  if (result.status !== 0) return null;
+  try {
+    return JSON.parse(result.stdout.trim());
+  } catch {
+    return null;
+  }
+}
+export {
+  mobileDiagnostics,
+  mobileObservation,
+  mobileRecording,
+  mobileRun
+};

package/dist/adapters/mobile/runtime-identity.js

@@ -0,0 +1,34 @@
+import { readAndroidNativeRuntimeIdentity } from "./release-artifact.js";
+import { readMobileReleaseArtifactState } from "./release-artifact-state.js";
+function withMobileNativeRuntimeIdentity(adapters, identity = {
+  state: readMobileReleaseArtifactState,
+  read: readAndroidNativeRuntimeIdentity
+}) {
+  return adapters.map((entry) => ({
+    ...entry,
+    async execute(node, context) {
+      const state = identity.state(context.projectRoot);
+      if (!state) {
+        if (context.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === "1") {
+          throw new Error("Mobile release-artifact actions require current trusted runtime state. Next: rerun runtime-launch with the exact artifact.");
+        }
+        return entry.execute(node, context);
+      }
+      identity.read(state);
+      const result = await entry.execute(node, context);
+      const nativeRuntimeIdentity = identity.read(state);
+      const output = result.output && typeof result.output === "object" && !Array.isArray(result.output) ? result.output : { result: result.output };
+      return {
+        ...result,
+        output: {
+          ...output,
+          nativeRuntimeIdentity,
+          runtimeSessionId: nativeRuntimeIdentity.runtimeSessionId
+        }
+      };
+    }
+  }));
+}
+export {
+  withMobileNativeRuntimeIdentity
+};

package/dist/adapters/mobile/surface.js

@@ -6,6 +6,13 @@ import { resolveMobileSlotPorts } from "../slot-ports.js";
 import { mobileRuntimeStatus } from "./prepare.js";
 import { hasRunwayProvisionBaseline, provisionRunwayMobile } from "./provision.js";
 import { adapterRegistry } from "../registry.js";
+import { writeInteractiveProgress } from "../../commands/shared.js";
+import { mobileActions } from "./actions.js";
+import { mobileHarness, mobilePrepare, mobileRuntimeContext } from "./overlay.js";
+import { mobileReadiness, mobileRuntimeDecision } from "./readiness.js";
+import { clearMobileReleaseArtifactState } from "./release-artifact-state.js";
+import { mobileDiagnostics, mobileObservation, mobileRecording, mobileRun } from "./run.js";
+import { mobileSourceFingerprint } from "./source-freshness.js";
 function mobileRuntimeNextAction(reasonCode, target, platform) {
   const resolved = shellQuote(path.resolve(target));
   return reasonCode === "deps-missing" || reasonCode === "deps-partial" || reasonCode === "deps-stale" ? `cd ${resolved} && yarn setup` : `mm-harness launch ${platform} --adapter mobile --target ${resolved}`;
@@ -34,7 +41,12 @@ const mobileSurface = {
   runwayProvision: {
     async run(target, options) {
       return provisionRunwayMobile(target, options);
-    }
+    },
+    before(target, { json, platform, resolveOnly }) {
+      writeInteractiveProgress(json, `\u2192 provision mobile ${platform} \u2014 resolving simulator and Runway artifact`);
+      if (!resolveOnly) clearMobileReleaseArtifactState(target);
+    },
+    launchNext: true
   },
   devServer: {
     label: "metro",
@@ -64,10 +76,34 @@ const mobileSurface = {
   launch: async (context) => {
     const [{ runDeviceLaunch }, { mobileLaunchProfile }] = await Promise.all([
       import("../../commands/launch/device.js"),
-      import("../../commands/launch/mobile.js")
+      import("./launch.js")
     ]);
     return runDeviceLaunch(context, mobileLaunchProfile);
-  }
+  },
+  actions: mobileActions,
+  harness: mobileHarness,
+  runtimeContext: mobileRuntimeContext,
+  readiness: mobileReadiness,
+  fixtures: {
+    operations: ["init", "sync", "set", "reset"],
+    apply: async (context) => (await import("./fixtures.js")).applyMobileFixture(context)
+  },
+  prepare: mobilePrepare,
+  debug: {
+    refuse: ({ worker }) => worker ? { message: "--worker is extension-only (service-worker DevTools). Use --dev-menu on mobile.", userAction: "mm-harness debug --dev-menu" } : void 0,
+    args: ({ devMenu }) => [
+      ...process.env.WATCHER_PORT ? ["--port", process.env.WATCHER_PORT] : [],
+      "--action",
+      devMenu ? "dev-menu" : "debug"
+    ]
+  },
+  reload: async (target, json) => (await import("./reload.js")).reloadMobile(target, json),
+  runtimeDecision: mobileRuntimeDecision,
+  run: mobileRun,
+  recording: mobileRecording,
+  diagnostics: mobileDiagnostics,
+  observation: mobileObservation,
+  sourceFingerprint: (root) => mobileSourceFingerprint(root)
 };
 adapterRegistry.register(mobileSurface);
 export {