@deeeed/metamask-harness 0.13.0 → 0.14.1

package/dist/commands/core-readiness.js

@@ -0,0 +1,75 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+const requireFromHarness = createRequire(import.meta.url);
+const CORE_RUNTIME_DEPS = ["immer"];
+function coreDependencyBlock(target) {
+  const resolved = path.resolve(target);
+  const nodeLinker = readYarnNodeLinker(resolved);
+  const installAction = `cd ${shellQuote(resolved)} && yarn install --immutable`;
+  if (nodeLinker === "pnp") {
+    if (!fs.existsSync(path.join(resolved, ".pnp.cjs"))) {
+      return {
+        code: "CORE_DEPS_MISSING",
+        message: "core dependencies are not installed for Yarn PnP (.pnp.cjs is missing).",
+        userAction: installAction
+      };
+    }
+    return null;
+  }
+  if (!fs.existsSync(path.join(resolved, "node_modules"))) {
+    return {
+      code: "CORE_DEPS_MISSING",
+      message: nodeLinker === "node-modules" ? "core dependencies are not installed (nodeLinker requires node_modules, but node_modules is missing)." : "core dependencies are not installed (node_modules is missing).",
+      userAction: installAction
+    };
+  }
+  if (!fs.existsSync(path.join(resolved, "node_modules/.bin/tsx"))) {
+    return {
+      code: "CORE_DEPS_INCOMPLETE",
+      message: "core dependencies are incomplete (node_modules/.bin/tsx is missing).",
+      userAction: installAction
+    };
+  }
+  for (const dependency of CORE_RUNTIME_DEPS) {
+    if (!canResolveFromTarget(dependency, resolved)) {
+      return {
+        code: "CORE_DEPS_INCOMPLETE",
+        message: `core dependencies are incomplete (cannot resolve ${dependency} from the target checkout).`,
+        userAction: installAction
+      };
+    }
+  }
+  return null;
+}
+function corePnpNodeOptions(target, current) {
+  if (readYarnNodeLinker(target) !== "pnp") return current;
+  const pnp = path.join(path.resolve(target), ".pnp.cjs");
+  if (!fs.existsSync(pnp)) return current;
+  const pnpOption = `--require ${pnp}`;
+  return current ? `${current} ${pnpOption}` : pnpOption;
+}
+function canResolveFromTarget(specifier, target) {
+  try {
+    requireFromHarness.resolve(specifier, { paths: [target] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readYarnNodeLinker(target) {
+  try {
+    const yarnrc = fs.readFileSync(path.join(target, ".yarnrc.yml"), "utf8");
+    const match = /^nodeLinker:\s*["']?([^"'\s#]+)["']?/mu.exec(yarnrc);
+    return match?.[1];
+  } catch {
+    return void 0;
+  }
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/gu, `'\\''`)}'`;
+}
+export {
+  coreDependencyBlock,
+  corePnpNodeOptions
+};

package/dist/commands/device-target.js

@@ -49,7 +49,13 @@ function renderDeviceList(devices, out) {
 }
 function deviceSelected(device) {
   if (device.platform === "android") {
-    return process.env.ADB_SERIAL === device.id || process.env.ANDROID_SERIAL === device.id;
+    if (process.env.ADB_SERIAL === device.id || process.env.ANDROID_SERIAL === device.id) return true;
+    const pinName = process.env.ANDROID_TARGET_DEVICE_NAME || process.env.ANDROID_DEVICE || "";
+    if (!pinName) return false;
+    if (pinName === device.id) return true;
+    const name = device.name ? normalizeDeviceName(device.name) : "";
+    const normalizedPin = normalizeDeviceName(pinName);
+    return Boolean(name && (normalizedPin === name || normalizedPin.startsWith(`${name} -`)));
   }
   return process.env.IOS_SIMULATOR === device.id || process.env.SIM_UDID === device.id || process.env.IOS_SIMULATOR === device.name;
 }
@@ -58,8 +64,20 @@ function isTargetable(device) {
   if (device.platform === "ios") return device.state === "Booted";
   return false;
 }
+function mobilePlatformPreference(options) {
+  const platform = optionString(options, "platform");
+  return platform === "ios" || platform === "android" ? platform : void 0;
+}
+function configuredPinForPlatform(platform) {
+  if (platform === "ios") return process.env.IOS_SIMULATOR || process.env.SIM_UDID || void 0;
+  return process.env.ADB_SERIAL || process.env.ANDROID_SERIAL || process.env.ANDROID_TARGET_DEVICE_NAME || process.env.ANDROID_DEVICE || void 0;
+}
+function oppositePlatform(platform) {
+  return platform === "ios" ? "android" : "ios";
+}
 function applyDeviceTargeting(command, adapter, options, opts) {
   const device = optionString(options, "device");
+  const platformPreference = mobilePlatformPreference(options);
   if (adapter !== "mobile") {
     if (device !== void 0) {
       return {
@@ -73,15 +91,26 @@ function applyDeviceTargeting(command, adapter, options, opts) {
   }
   if (device !== void 0) {
     const connected2 = listConnectedDevices();
+    const setResolvedDevice = (matched) => {
+      if (platformPreference && matched.platform !== platformPreference) {
+        return {
+          ok: false,
+          code: "DEVICE_PLATFORM_CONFLICT",
+          message: `--device ${device} resolves to ${matched.platform}, but --platform ${platformPreference} was requested.
+  To use this device intentionally, drop --platform ${platformPreference} or choose a ${platformPreference} device.`
+        };
+      }
+      if (matched.platform === "android") setAndroidDeviceEnv(matched.id, matched.name);
+      else setIosDeviceEnv(matched.id, matched.name);
+      return { ok: true };
+    };
     const androidById = connected2.find((d) => d.platform === "android" && d.id === device);
     if (androidById) {
-      setAndroidDeviceEnv(device, androidById.name);
-      return { ok: true };
+      return setResolvedDevice(androidById);
     }
     const iosById = connected2.find((d) => d.platform === "ios" && d.id === device);
     if (iosById) {
-      setIosDeviceEnv(device, iosById.name);
-      return { ok: true };
+      return setResolvedDevice(iosById);
     }
     const normalizedDevice = normalizeDeviceName(device);
     const byName = connected2.filter((d) => {
@@ -90,10 +119,7 @@ function applyDeviceTargeting(command, adapter, options, opts) {
       return name === device || normalizedName === normalizedDevice || d.platform === "android" && normalizedDevice.startsWith(`${normalizedName} -`);
     });
     if (byName.length === 1) {
-      const matched = byName[0];
-      if (matched.platform === "android") setAndroidDeviceEnv(matched.id, matched.name);
-      else setIosDeviceEnv(matched.id, matched.name);
-      return { ok: true };
+      return setResolvedDevice(byName[0]);
     }
     if (byName.length > 1) {
       return {
@@ -111,9 +137,85 @@ function applyDeviceTargeting(command, adapter, options, opts) {
 ${formatConnectedDevices(connected2)}` : `  No devices are currently connected (adb devices / booted iOS simulators).`)
     };
   }
-  if (!opts.gate) return { ok: true };
   const connected = listConnectedDevices();
   const targetable = connected.filter(isTargetable);
+  if (platformPreference) {
+    const selectedTargetable2 = targetable.filter(deviceSelected);
+    const platformTargetable = targetable.filter((d) => d.platform === platformPreference);
+    const selectedPlatformTargetable = platformTargetable.filter(deviceSelected);
+    const configuredPin = configuredPinForPlatform(platformPreference);
+    const oppositePin = configuredPinForPlatform(oppositePlatform(platformPreference));
+    if (selectedPlatformTargetable.length === 1) {
+      const selected = selectedPlatformTargetable[0];
+      if (selected.platform === "android") setAndroidDeviceEnv(selected.id, selected.name);
+      else setIosDeviceEnv(selected.id, selected.name);
+      return { ok: true };
+    }
+    if (selectedTargetable2.length > 0) {
+      return {
+        ok: false,
+        code: "DEVICE_PLATFORM_CONFLICT",
+        message: `--platform ${platformPreference} conflicts with the current slot-selected device.
+  Selected devices:
+${formatConnectedDevices(selectedTargetable2)}
+  To use a different connected device intentionally, pass --device <id>.`
+      };
+    }
+    if (!configuredPin && oppositePin) {
+      return {
+        ok: false,
+        code: "DEVICE_PLATFORM_CONFLICT",
+        message: `--platform ${platformPreference} conflicts with the configured slot target.
+  Configured ${oppositePlatform(platformPreference)} target: ${oppositePin}
+  To use a different connected device intentionally, pass --device <id>.`
+      };
+    }
+    if (configuredPin) {
+      if (command === "launch" || !opts.gate) return { ok: true };
+      return {
+        ok: false,
+        code: "DEVICE_PLATFORM_PIN_NOT_READY",
+        message: `--platform ${platformPreference} matches the configured slot target, but that target is not ready.
+  Configured target: ${configuredPin}
+  Connected devices:
+${connected.length > 0 ? formatConnectedDevices(connected) : "    - none"}
+  Next: run mm-harness launch ${platformPreference}, or pass --device <id> to intentionally use another target.`
+      };
+    }
+    if (platformTargetable.length === 1) {
+      const selected = platformTargetable[0];
+      if (selected.platform === "android") setAndroidDeviceEnv(selected.id, selected.name);
+      else setIosDeviceEnv(selected.id, selected.name);
+      return { ok: true };
+    }
+    if (platformTargetable.length === 0) {
+      if (command === "launch" && platformPreference === "ios") return { ok: true };
+      return {
+        ok: false,
+        code: "DEVICE_PLATFORM_NOT_FOUND",
+        message: `--platform ${platformPreference} did not match any ready connected device.
+` + (connected.length > 0 ? `  Connected devices:
+${formatConnectedDevices(connected)}` : `  No devices are currently connected (adb devices / booted iOS simulators).`)
+      };
+    }
+    return {
+      ok: false,
+      code: "DEVICE_PLATFORM_AMBIGUOUS",
+      message: `${platformTargetable.length} ${platformPreference} devices available \u2014 ${command} needs exactly one target.
+  Connected devices:
+${formatConnectedDevices(connected)}
+  Add --device <id> to disambiguate, e.g.:${platformTargetable.map((d) => `
+    --device ${d.id}`).join("")}`
+    };
+  }
+  const selectedTargetable = targetable.filter(deviceSelected);
+  if (selectedTargetable.length === 1) {
+    const selected = selectedTargetable[0];
+    if (selected.platform === "android") setAndroidDeviceEnv(selected.id, selected.name);
+    else setIosDeviceEnv(selected.id, selected.name);
+    return { ok: true };
+  }
+  if (!opts.gate) return { ok: true };
   if (targetable.length > 1) {
     return {
       ok: false,
@@ -121,15 +223,23 @@ ${formatConnectedDevices(connected2)}` : `  No devices are currently connected (
       message: `${targetable.length} mobile devices available \u2014 ${command} needs exactly one target.
   Connected devices:
 ${formatConnectedDevices(connected)}
-  Add --device <id> to disambiguate, e.g.:${targetable.map((d) => `
-    --device ${d.id}`).join("")}`
+` + (selectedTargetable.length > 1 ? `  The current slot context selects more than one target; fix the slot device pins or add --device <id>.` : `  Add --device <id> to disambiguate, e.g.:${targetable.map((d) => `
+    --device ${d.id}`).join("")}`)
     };
   }
   return { ok: true };
 }
+function scopedDevices(devices, allDevices = false) {
+  const withSelection = devices.map((device) => ({ ...device, selected: deviceSelected(device) }));
+  if (allDevices) return withSelection;
+  const selected = withSelection.filter((device) => device.selected);
+  return selected.length > 0 ? selected : withSelection;
+}
 export {
   applyDeviceTargeting,
   deviceSelected,
   formatConnectedDevices,
-  renderDeviceList
+  mobilePlatformPreference,
+  renderDeviceList,
+  scopedDevices
 };

package/dist/commands/doctor.js

@@ -7,8 +7,14 @@ import { assertAdapter, runnerDir } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
 import { loadActionManifest, validateManifest } from "../manifest.js";
 import { ensureOverlay, newHealState, recipeRunning } from "../heal-bounds.js";
-import { listConnectedDevices } from "../devices.js";
-import { applyDeviceTargeting, deviceSelected, renderDeviceList } from "./device-target.js";
+import { applyDeviceTargeting } from "./device-target.js";
+import {
+  mobileDeviceView,
+  mobileDeviceLiveView,
+  renderAdditionalReachableDevices,
+  renderMobileDeviceList,
+  renderMobileLiveBlock
+} from "./mobile-device-view.js";
 import { ADAPTER_DETECT_NEXT, EXIT, usageOut } from "./shared.js";
 import {
   actionManifestPathOption,
@@ -35,18 +41,14 @@ async function handleDoctor({ options }) {
   const target = targetPath(options);
   const json = optionFlag(options, "json");
   const expectLive = optionFlag(options, "expectLive");
-  const explicitAdapter = optionString(options, "adapter") ?? optionString(options, "platform");
+  const allDevices = optionFlag(options, "allDevices");
+  const platformOption = optionString(options, "platform");
+  const explicitAdapter = optionString(options, "adapter") ?? (platformOption === "ios" || platformOption === "android" ? "mobile" : platformOption);
   const adapter = explicitAdapter ?? detectAdapter(target);
   if (!adapter) {
     return usageOut(json, "doctor", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
   }
   assertAdapter(adapter);
-  const dtResult = applyDeviceTargeting("doctor", adapter, options, { gate: false, rerun: "" });
-  if ("code" in dtResult) {
-    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "doctor", adapter, target, error: { code: dtResult.code, message: dtResult.message } }, null, 2));
-    else console.error(`\u2717 doctor: ${dtResult.message}`);
-    return EXIT.usage;
-  }
   const actionManifestPath = actionManifestPathOption(options, adapter);
   const manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
   const manifestValidation = await validateManifest(manifest);
@@ -62,15 +64,24 @@ async function handleDoctor({ options }) {
   try {
     const surface = getAdapterSurface(adapter);
     surface.resolveSlotPorts(target);
+    const dtResult = applyDeviceTargeting("doctor", adapter, options, { gate: false, rerun: "" });
+    if ("code" in dtResult) {
+      if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "doctor", adapter, target, error: { code: dtResult.code, message: dtResult.message } }, null, 2));
+      else console.error(`\u2717 doctor: ${dtResult.message}`);
+      return EXIT.usage;
+    }
     applyDoctorRuntimePorts(options);
     runtime = await surface.runtimeStatus(target);
   } catch {
   }
   const orphanMetros = adapter === "mobile" ? detectOrphanMetros(target, process.env.WATCHER_PORT) : [];
   const capture = captureHelperHealth();
-  const devices = adapter === "mobile" ? enumerateSelectedDevices() : [];
-  if (expectLive) return emitExpectLive(adapter, target, runtime, result, orphanMetros, capture, devices, json);
-  if (json) console.log(JSON.stringify({ ...result, runtime, orphanMetros, capture, devices }, null, 2));
+  const deviceView = adapter === "mobile" ? mobileDeviceView(allDevices) : null;
+  const liveView = deviceView ? await mobileDeviceLiveView(target, deviceView) : null;
+  const devices = liveView?.devicesWithLive ?? deviceView?.devices ?? [];
+  const additionalReachableDevices = liveView?.additionalReachableDevices ?? [];
+  if (expectLive) return emitExpectLive(adapter, target, runtime, result, orphanMetros, capture, devices, additionalReachableDevices, json);
+  if (json) console.log(JSON.stringify({ ...result, runtime, orphanMetros, capture, devices, additionalReachableDevices }, null, 2));
   else {
     const out = (style, text) => color(style, text, { stream: process.stdout });
     const stateStyle = (value, good) => value === good ? "ok" : "warn";
@@ -100,17 +111,18 @@ async function handleDoctor({ options }) {
         console.log(`  ${out("dim", "Next: grant Screen Recording (System Settings \u2192 Privacy & Security \u2192 Screen Recording), or run: capture-helper doctor --open-permissions")}`);
       }
     }
-    if (adapter === "mobile") renderDeviceList(devices, out);
+    if (adapter === "mobile") {
+      if (deviceView) renderMobileDeviceList(deviceView, out);
+      if (additionalReachableDevices.length > 0) renderAdditionalReachableDevices(additionalReachableDevices, out);
+      if (liveView) renderMobileLiveBlock(deviceView?.devices ?? [], liveView.liveMap, out);
+    }
   }
   return result.status === "pass" ? 0 : 1;
 }
-function enumerateSelectedDevices() {
-  return listConnectedDevices().map((device) => ({ ...device, selected: deviceSelected(device) }));
-}
-function emitExpectLive(adapter, target, runtime, result, orphanMetros, capture, devices, json) {
+function emitExpectLive(adapter, target, runtime, result, orphanMetros, capture, devices, additionalReachableDevices, json) {
   const live = runtime?.decision === "ready";
   if (json) {
-    console.log(JSON.stringify({ ...result, runtime, orphanMetros, capture, devices }, null, 2));
+    console.log(JSON.stringify({ ...result, runtime, orphanMetros, capture, devices, additionalReachableDevices }, null, 2));
     return live ? EXIT.ok : EXIT.runtime;
   }
   const out = (style, text) => color(style, text, { stream: process.stdout });

package/dist/commands/fixtures.js

@@ -39,13 +39,14 @@ async function handleFixtures(argv, deps) {
   if (!adapter) {
     return usageOut(json, "fixtures", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
   }
+  const surface = getAdapterSurface(adapter);
+  surface.resolveSlotPorts(target);
   const dtResult = applyDeviceTargeting("fixtures", adapter, options, { gate: false, rerun: "" });
   if ("code" in dtResult) {
     return usageOut(json, "fixtures", dtResult.message, "mm-harness fixtures set --adapter mobile --device <adb-serial|simulator-udid>");
   }
   if (sub === "generate") return fixturesGenerate(adapter, target, options, json);
   if (sub === "finalize") return fixturesFinalize(adapter, target, options, json);
-  const surface = getAdapterSurface(adapter);
   if (surface.headless) return usageOut(json, "fixtures", "core is headless; it has no wallet fixture.", surface.hints.launch);
   const canonicalFixture = walletFixturePath(target);
   const retryHint = `${surface.hints.relaunch}   # relaunch, then retry: mm-harness fixtures set`;

package/dist/commands/launch/extension.js

@@ -4,7 +4,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { depsCheck } from "@farmslot/recipe-harness/runtime/deps-readiness";
 import { recipeHarnessPath, recipeRuntimeDir, runnerDir } from "../../paths.js";
+import { extensionIdFromKey } from "../../adapters/extension/extension-id.js";
 import { isExtensionDistStale } from "../../adapters/extension/runtime-decision.js";
+import { checkExtensionRuntimeHealth } from "../../adapters/extension/runtime.js";
 import { stopExtensionWatcher } from "../../adapters/slot-ports.js";
 import { spawnScriptStreaming } from "../shared.js";
 function extensionDepsBlock(target) {
@@ -22,7 +24,7 @@ function extensionDepsBlock(target) {
   }
   return null;
 }
-async function launchExtension(target, tier, wantWatch) {
+async function launchExtension(target, tier, wantWatch, displayMode = "fullscreen") {
   if (wantWatch) {
     const startWatchSh = path.join(runnerDir, "adapters/extension/start-watch.sh");
     const watchArgs = ["--target", target];
@@ -34,29 +36,53 @@ async function launchExtension(target, tier, wantWatch) {
     return extensionRebuild(target);
   }
   if (await extensionRuntimeReusable(target)) {
-    return extensionReattach(target);
+    return extensionReattach(target, displayMode);
   }
   return extensionRebuild(target);
 }
 async function extensionRuntimeReusable(target) {
-  const watcherPort = process.env.WATCHER_PORT;
   const cdpPort = process.env.CDP_PORT;
-  if (!watcherPort || !cdpPort) return false;
-  if (!portHasListener(watcherPort)) return false;
+  if (!cdpPort) return false;
+  if (!cdpOwnedByExpectedRuntime(cdpPort, target)) return false;
   if (!await cdpVersionReachable(cdpPort)) return false;
+  if (!await cdpHasExpectedExtensionTarget(cdpPort, target)) return false;
+  if (!await cdpRuntimeHealthy(cdpPort, target)) return false;
   if (isExtensionDistStale(target)) return false;
   return true;
 }
-function portHasListener(port) {
+function expectedChromeProfile(target) {
+  const profileName = process.env.RECIPE_CHROME_PROFILE_NAME || "chrome-profile";
+  return path.resolve(process.env.CHROME_USER_DATA_DIR || path.join(target, recipeRuntimeDir(), profileName));
+}
+function expectedRuntimeDist(target) {
+  return path.resolve(path.join(target, recipeRuntimeDir(), process.env.RECIPE_RUNTIME_DIST_DIR || "runtime-dist"));
+}
+function cdpOwnedByExpectedRuntime(port, target) {
+  let pids = [];
   try {
     const out = execFileSync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
-    return out.split(/\s+/u).some((value) => /^\d+$/u.test(value));
+    pids = out.split(/\s+/u).filter((value) => /^\d+$/u.test(value));
   } catch {
     return false;
   }
+  const profile = expectedChromeProfile(target);
+  const runtimeDist = expectedRuntimeDist(target);
+  for (const pid of pids) {
+    try {
+      const command = execFileSync("ps", ["-ww", "-o", "command=", "-p", pid], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      if (command.includes(`--user-data-dir=${profile}`) && (command.includes(`--load-extension=${runtimeDist}`) || command.includes(`--disable-extensions-except=${runtimeDist}`))) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
 }
 function cdpVersionReachable(port) {
   return new Promise((resolve) => {
@@ -75,9 +101,79 @@ function cdpVersionReachable(port) {
     request.on("error", () => resolve(false));
   });
 }
-async function extensionReattach(target) {
+function expectedExtensionId(target) {
+  const runtimeDir = recipeRuntimeDir();
+  try {
+    const manifest = JSON.parse(
+      fs.readFileSync(path.join(target, runtimeDir, process.env.RECIPE_RUNTIME_DIST_DIR || "runtime-dist", "manifest.json"), "utf8")
+    );
+    if (typeof manifest.key === "string" && manifest.key) return extensionIdFromKey(manifest.key);
+  } catch {
+  }
+  try {
+    const marker = fs.readFileSync(path.join(target, runtimeDir, "extension.id"), "utf8").trim();
+    return /^[a-p]{32}$/u.test(marker) ? marker : null;
+  } catch {
+    return null;
+  }
+}
+function cdpHasExpectedExtensionTarget(port, target) {
+  return new Promise((resolve) => {
+    const request = http.get(
+      { host: "127.0.0.1", port: Number(port), path: "/json/list", timeout: 2e3 },
+      (response) => {
+        let body = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          body += chunk;
+        });
+        response.on("end", () => {
+          if ((response.statusCode ?? 0) < 200 || (response.statusCode ?? 0) >= 300) {
+            resolve(false);
+            return;
+          }
+          let targets;
+          try {
+            targets = JSON.parse(body);
+          } catch {
+            resolve(false);
+            return;
+          }
+          if (!Array.isArray(targets)) {
+            resolve(false);
+            return;
+          }
+          const expectedId = expectedExtensionId(target);
+          if (!expectedId) {
+            resolve(false);
+            return;
+          }
+          resolve(targets.some((entry) => {
+            if (!entry || typeof entry !== "object") return false;
+            const candidate = entry;
+            return typeof candidate.url === "string" && candidate.url.startsWith(`chrome-extension://${expectedId}/`);
+          }));
+        });
+      }
+    );
+    request.on("timeout", () => {
+      request.destroy();
+      resolve(false);
+    });
+    request.on("error", () => resolve(false));
+  });
+}
+async function cdpRuntimeHealthy(port, target) {
+  try {
+    const report = await checkExtensionRuntimeHealth(target, Number(port), { pageMode: "home-or-sidepanel" });
+    return report.status === "PASS";
+  } catch {
+    return false;
+  }
+}
+async function extensionReattach(target, displayMode = "fullscreen") {
   const reattachScript = recipeHarnessPath(target, "extension", "scripts", "reattach.sh");
-  const reattachArgs = ["--target", target];
+  const reattachArgs = ["--target", target, "--display-mode", displayMode];
   if (process.env.CDP_PORT) reattachArgs.push("--cdp-port", process.env.CDP_PORT);
   if (process.env.WATCHER_PORT) reattachArgs.push("--watcher-port", process.env.WATCHER_PORT);
   if (process.env.EXTENSION_START_URL) reattachArgs.push("--start-url", process.env.EXTENSION_START_URL);