@deeeed/metamask-harness 0.75.0 → 0.76.0

package/dist/adapters/mobile/fixtures.js

@@ -0,0 +1,141 @@
+import path from "node:path";
+import { EXIT, spawnScriptStreaming } from "../../commands/shared.js";
+import { runnerDir } from "../../paths.js";
+import { FIXTURE_STREAM_TIMEOUT_MS } from "../../commands/fixtures.js";
+const FIXTURE_BRIDGE_READY_TIMEOUT_MS = 18e4;
+const MOBILE_SETUP_WALLET_TIMEOUT_MS = 36e4;
+async function applyMobileFixture({
+  target,
+  sub,
+  fixturePath,
+  canonicalFixture,
+  fixtureFlags,
+  json,
+  retryHint
+}) {
+  const adapter = "mobile";
+  const fixtureFlagsJson = JSON.stringify(fixtureFlags);
+  const reset = sub === "reset";
+  process.stderr.write(`\u2192 fixtures ${sub} ${adapter} \u2014 ${reset ? "resetting selected app data, relaunching, then applying" : "connecting bridge + applying"} wallet fixture (can take ~30s)\u2026
+`);
+  let status;
+  let mobileSetupResult;
+  let resetError;
+  const setupWalletSh = path.join(runnerDir, "adapters/mobile/bridge-runtime/setup-wallet.sh");
+  const previousAppRoot = process.env.APP_ROOT;
+  process.env.APP_ROOT = target;
+  try {
+    if (reset) {
+      const platform = process.env.PLATFORM === "android" || process.env.ADB_SERIAL || process.env.ANDROID_SERIAL ? "android" : "ios";
+      const port = process.env.WATCHER_PORT ?? process.env.METRO_PORT ?? "8081";
+      const resetAppData = path.join(runnerDir, "adapters/mobile/reset-app-data.sh");
+      const resetArgs = ["--platform", platform, "--target", target];
+      if (platform === "ios") {
+        resetArgs.push("--simulator", process.env.SIM_UDID || process.env.IOS_SIMULATOR || "booted");
+      } else if (process.env.ADB_SERIAL || process.env.ANDROID_SERIAL) {
+        resetArgs.push("--adb-serial", process.env.ADB_SERIAL || process.env.ANDROID_SERIAL || "");
+      }
+      const resetResult = await spawnScriptStreaming(resetAppData, resetArgs, target, {
+        timeoutMs: FIXTURE_STREAM_TIMEOUT_MS
+      });
+      if (resetResult.status !== 0) {
+        resetError = new Error("Mobile app data reset failed.");
+      } else {
+        const prewarmBundle = path.join(runnerDir, "adapters/mobile/prewarm-bundle.sh");
+        const prewarmResult = await spawnScriptStreaming(
+          prewarmBundle,
+          ["--platform", platform, "--target", target, "--port", port],
+          target,
+          {
+            timeoutMs: FIXTURE_STREAM_TIMEOUT_MS
+          }
+        );
+        if (prewarmResult.status !== 0) {
+          resetError = new Error("Mobile bundle prewarm failed after app data reset.");
+        }
+      }
+      if (!resetError) {
+        const openDevice = path.join(runnerDir, "adapters/mobile/open-device.sh");
+        const openArgs = ["--platform", platform, "--target", target, "--port", port, "--preflight-mode", "fast", "--restart"];
+        if (platform === "ios") {
+          openArgs.push("--simulator", process.env.SIM_UDID || process.env.IOS_SIMULATOR || "booted");
+        } else if (process.env.ADB_SERIAL || process.env.ANDROID_SERIAL) {
+          openArgs.push("--adb-serial", process.env.ADB_SERIAL || process.env.ANDROID_SERIAL || "");
+        }
+        const openResult = await spawnScriptStreaming(openDevice, openArgs, target, {
+          timeoutMs: FIXTURE_STREAM_TIMEOUT_MS
+        });
+        if (openResult.status !== 0) {
+          resetError = new Error("Mobile app relaunch after data reset failed.");
+        } else {
+          const waitForBridge = path.join(runnerDir, "adapters/mobile/wait-for-bridge.sh");
+          const waitResult = await spawnScriptStreaming(
+            waitForBridge,
+            ["--target", target, "--port", port, "--platform", platform, "--timeout-ms", String(FIXTURE_BRIDGE_READY_TIMEOUT_MS)],
+            target,
+            { timeoutMs: FIXTURE_BRIDGE_READY_TIMEOUT_MS + 1e4 }
+          );
+          if (waitResult.status !== 0) {
+            resetError = new Error("Mobile bridge did not return after app data reset.");
+          }
+        }
+      }
+    }
+    const configuredTimeout = Number(process.env.MM_HARNESS_FIXTURES_SET_TIMEOUT_MS ?? MOBILE_SETUP_WALLET_TIMEOUT_MS);
+    const timeoutMs = Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? configuredTimeout : MOBILE_SETUP_WALLET_TIMEOUT_MS;
+    if (!resetError) {
+      mobileSetupResult = await spawnScriptStreaming(
+        setupWalletSh,
+        ["--fixture", fixturePath, "--remote-flags-json", fixtureFlagsJson],
+        target,
+        {
+          env: {
+            APP_ROOT: target,
+            WATCHER_PORT: process.env.WATCHER_PORT ?? "8081",
+            METRO_PORT: process.env.METRO_PORT ?? process.env.WATCHER_PORT ?? "8081"
+          },
+          timeoutMs
+        }
+      );
+    }
+    status = !resetError && mobileSetupResult?.status === 0 ? "pass" : "fail";
+  } finally {
+    if (previousAppRoot === void 0) delete process.env.APP_ROOT;
+    else process.env.APP_ROOT = previousAppRoot;
+  }
+  if (!json && status === "fail") {
+    console.error(`  Next: ${retryHint}`);
+  }
+  const teaching = status === "pass" ? `Wallet fixture applied.  Want different accounts? Edit: ${canonicalFixture}` : "Wallet fixture was not applied.";
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          command: "fixtures",
+          action: sub,
+          adapter,
+          fixture: fixturePath,
+          canonicalFixture,
+          status,
+          exitCode: status === "pass" ? EXIT.ok : EXIT.runtime,
+          walletReset: reset && status === "pass",
+          message: teaching,
+          error: status === "fail" ? {
+            code: resetError ? "MOBILE_WALLET_RESET_FAILED" : mobileSetupResult?.timedOut ? "SETUP_WALLET_TIMEOUT" : "SETUP_WALLET_FAILED",
+            message: resetError ? `wallet reset failed: ${resetError instanceof Error ? resetError.message : String(resetError)}` : mobileSetupResult?.timedOut ? `wallet fixture setup exceeded its ${String(mobileSetupResult.timeoutMs)}ms bound on Metro port ${process.env.WATCHER_PORT ?? "8081"}` : `wallet fixture setup failed on ${process.env.WATCHER_PORT ?? "8081"}`,
+            userAction: retryHint
+          } : null
+        },
+        null,
+        2
+      )
+    );
+  } else if (status === "pass") {
+    console.error(teaching);
+  }
+  return status === "pass" ? EXIT.ok : EXIT.runtime;
+}
+export {
+  applyMobileFixture
+};

package/dist/adapters/mobile/overlay.js

@@ -0,0 +1,27 @@
+import { mobilePlatformFromConfiguredTarget, mobilePlatformFromDevices, readRuntimeContextTarget } from "./prepare-target.js";
+const mobileHarness = {
+  install: { entry: "adapters/mobile/inject.sh", fallback: "scripts/inject-mobile-harness.sh" },
+  cleanup: { entry: "adapters/mobile/cleanup.sh", fallback: "scripts/cleanup-mobile-harness.sh", fromInstalledRunner: true },
+  // Runner-owned typed code, not a shipped leaf: no installed overlay copy can shadow it.
+  verify: () => ({ inProcess: async () => (await import("./verify.js")).runMobileVerify }),
+  restart: "mm-harness launch ios   # or launch android"
+};
+const mobileRuntimeContext = {
+  forbiddenFields: ["cdpPort", "extensionId"],
+  localPorts: { watcher: 4e4 },
+  resources: ({ watcherPort, existing }) => ({
+    metroPort: watcherPort,
+    simulator: process.env.IOS_SIMULATOR || existing.simulator,
+    simulatorUdid: process.env.SIM_UDID || existing.simulatorUdid,
+    adbSerial: process.env.ADB_SERIAL || process.env.ANDROID_SERIAL || existing.adbSerial
+  })
+};
+const mobilePrepare = {
+  clearMetro: true,
+  devicePlatform: (target, devices) => mobilePlatformFromConfiguredTarget(process.env, readRuntimeContextTarget(target)) ?? mobilePlatformFromDevices(devices)
+};
+export {
+  mobileHarness,
+  mobilePrepare,
+  mobileRuntimeContext
+};

package/dist/adapters/mobile/prepare-target.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+import { recipeRuntimeDir } from "../../paths.js";
+function readRuntimeContextTarget(target) {
+  const file = path.join(target, recipeRuntimeDir(), "agentic-runtime.json");
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+  const record = parsed ?? {};
+  const str = (key) => typeof record[key] === "string" ? record[key] : void 0;
+  return { simulator: str("simulator"), simulatorUdid: str("simulatorUdid"), adbSerial: str("adbSerial") };
+}
+function mobilePlatformFromConfiguredTarget(env, context) {
+  const ios = Boolean(env.IOS_SIMULATOR || env.SIM_UDID || context.simulator || context.simulatorUdid);
+  const android = Boolean(
+    env.ADB_SERIAL || env.ANDROID_SERIAL || env.ANDROID_TARGET_DEVICE_NAME || env.ANDROID_DEVICE || context.adbSerial
+  );
+  if (ios === android) return void 0;
+  return ios ? "ios" : "android";
+}
+function mobilePlatformFromDevices(devices) {
+  const selected = devices.filter((device) => device?.selected === true);
+  const candidates = selected.length > 0 ? selected : devices;
+  const platforms = [
+    ...new Set(
+      candidates.map((device) => device?.platform).filter((value) => value === "ios" || value === "android")
+    )
+  ];
+  return platforms.length === 1 ? platforms[0] : void 0;
+}
+export {
+  mobilePlatformFromConfiguredTarget,
+  mobilePlatformFromDevices,
+  readRuntimeContextTarget
+};

package/dist/adapters/mobile/readiness.js

@@ -0,0 +1,39 @@
+import { optionFlag, optionString, parsePort } from "../../commands/parse-args.js";
+import { detectOrphanMetros, mobileToolDoctorChecks } from "./doctor-checks.js";
+import { ensureMobilePerpsEnvironment, mobilePerpsEnvironment } from "./perps-env.js";
+const mobileReadiness = {
+  compatibilityMode(_target, shape) {
+    if (shape.injectedHarness && shape.agenticService) return "runner bridge with injected app bridge";
+    if (shape.agenticService) return "runner bridge with app bridge";
+    return "runner bridge available; app bridge not installed";
+  },
+  checks: (_target, platform) => mobileToolDoctorChecks(platform === "ios" || platform === "android" ? platform : void 0),
+  environment: (target) => ({ mobilePerps: mobilePerpsEnvironment(target) }),
+  lines(target) {
+    const perps = mobilePerpsEnvironment(target);
+    return [
+      `mobile-perps: ${perps.status} (${perps.file}; MM_PERPS_ENABLED=${perps.perpsEnabled.value ?? "missing"}; OVERRIDE_REMOTE_FEATURE_FLAGS=${perps.remoteFeatureFlagOverride.value ?? "missing"})`
+    ];
+  },
+  orphanDevServers: detectOrphanMetros,
+  captureProviders: ["simctl", "adb"],
+  fixes: [{ id: "mobile-perps-env", apply: (target) => ensureMobilePerpsEnvironment(target).length > 0 }],
+  devices: async () => (await import("./devices.js")).mobileDevices
+};
+async function mobileRuntimeDecision(target, options) {
+  const watcherPortRaw = optionString(options, "watcherPort") ?? process.env.WATCHER_PORT ?? process.env.METRO_PORT;
+  const watcherPort = watcherPortRaw === void 0 ? void 0 : parsePort(watcherPortRaw, "runtime-decision --watcher-port must be a port.");
+  const { decideMobileReadiness } = await import("./runtime-decision.js");
+  const report = await decideMobileReadiness(target, {
+    watcherPort,
+    metroLog: optionString(options, "metroLog"),
+    platform: optionString(options, "platform") ?? process.env.PLATFORM ?? process.env.RECIPE_HARNESS_PLATFORM,
+    record: optionFlag(options, "record"),
+    preflightMode: optionString(options, "preflightMode")
+  });
+  return { report, line: `${report.decision} ${report.reasonCode} \u2014 ${report.reasons[0] ?? ""}` };
+}
+export {
+  mobileReadiness,
+  mobileRuntimeDecision
+};

package/dist/adapters/mobile/reload.js

@@ -0,0 +1,15 @@
+import path from "node:path";
+import { EXIT, spawnScript } from "../../commands/shared.js";
+import { runnerDir } from "../../paths.js";
+function reloadMobile(target, json) {
+  const script = path.join(runnerDir, "adapters/mobile/reload-app.mjs");
+  const args = [];
+  if (process.env.WATCHER_PORT) args.push("--port", process.env.WATCHER_PORT);
+  if (json) args.push("--json");
+  const result = spawnScript(process.execPath, [script, ...args], target, json);
+  if (json) process.stdout.write(result.output);
+  return result.status === 0 ? EXIT.ok : EXIT.runtime;
+}
+export {
+  reloadMobile
+};

package/dist/adapters/mobile/surface.js

@@ -6,7 +6,11 @@ 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) {
@@ -37,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",
@@ -72,6 +81,24 @@ const mobileSurface = {
     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,

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/surface.js

@@ -5,6 +5,8 @@ import { TERMINAL_CONSOLE_FILES, terminalRuntimeFile } from "./console-capture.j
 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) {
@@ -33,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(),
@@ -101,6 +103,17 @@ const terminalSurface = {
   },
   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
 };

package/dist/cli.js

@@ -1,3 +1,4 @@
+import { adapterRegistry } from "./adapters/registry.js";
 import { detectAdapter, handleHarness } from "./harness.js";
 import { handleActions } from "./commands/manifest.js";
 import { handleDoctor } from "./commands/doctor.js";
@@ -108,7 +109,8 @@ async function main(argv) {
         const { options } = parseArgs(argv.slice(1), command);
         const target = targetPath(options);
         const adapterRaw = (typeof options["adapter"] === "string" ? options["adapter"] : void 0) ?? (typeof options["platform"] === "string" ? options["platform"] : void 0) ?? detectAdapter(target);
-        if (adapterRaw === "mobile" || adapterRaw === "extension" || adapterRaw === "core" || adapterRaw === "terminal") {
+        await import("./adapters/surface.js");
+        if (adapterRaw && adapterRegistry.has(adapterRaw)) {
           await handleHarness(["install", "--platform", adapterRaw, "--target", target, "--quiet"]);
         }
       } catch {

package/dist/commands/debug.js

@@ -10,36 +10,17 @@ async function handleDebug(argv) {
   const adapter = resolveAdapter(options, target);
   if (!adapter) return usageOut(json, "debug", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
   const surface = getAdapterSurface(adapter);
-  if (surface.headless) return usageOut(json, "debug", "core is headless; there is no debug console.", surface.hints.relaunch);
+  if (surface.headless) return usageOut(json, "debug", `${adapter} is headless; there is no debug console.`, surface.hints.relaunch);
   surface.resolveSlotPorts(target);
   const worker = flag(options, "worker");
   const devMenu = flag(options, "devMenu");
   const noOpen = flag(options, "noOpen");
-  if (adapter === "mobile" && worker) {
-    return usageOut(
-      json,
-      "debug",
-      "--worker is extension-only (service-worker DevTools). Use --dev-menu on mobile.",
-      "mm-harness debug --dev-menu"
-    );
-  }
-  if (adapter === "extension" && devMenu) {
-    return usageOut(
-      json,
-      "debug",
-      "--dev-menu is mobile-only (RN developer menu). Use --worker on the extension.",
-      "mm-harness debug --worker"
-    );
-  }
+  const debug = surface.debug;
+  if (!debug) return usageOut(json, "debug", `${adapter} has no debug console.`, surface.hints.relaunch);
+  const refused = debug.refuse?.({ worker, devMenu });
+  if (refused) return usageOut(json, "debug", refused.message, refused.userAction);
   const openDebug = path.join(runnerDir, "adapters/shared/open-debug.mjs");
-  const debugArgs = ["--adapter", adapter];
-  if (adapter === "extension") {
-    if (process.env.CDP_PORT) debugArgs.push("--cdp-port", process.env.CDP_PORT);
-    debugArgs.push("--target", worker ? "worker" : "page");
-  } else {
-    if (process.env.WATCHER_PORT) debugArgs.push("--port", process.env.WATCHER_PORT);
-    debugArgs.push("--action", devMenu ? "dev-menu" : "debug");
-  }
+  const debugArgs = ["--adapter", adapter, ...debug.args({ worker, devMenu })];
   if (json) debugArgs.push("--json");
   if (noOpen) debugArgs.push("--no-open");
   const result = spawnScript(process.execPath, [openDebug, ...debugArgs], target, json);

package/dist/commands/device-target.js

@@ -4,6 +4,7 @@ import {
   findAvailableIosSimulatorById,
   listConnectedDevices
 } from "../devices.js";
+import { getAdapterSurface } from "../adapters/surface.js";
 import { persistExplicitDevicePin } from "../runtime-context.js";
 import { optionString, shellQuoteArg, targetPath } from "./parse-args.js";
 const DEVICE_SELECT_HINT = "Pass --device <name|udid|serial> to select one target. Do not shut down other connected devices to force selection.";
@@ -97,7 +98,7 @@ function deviceRecovery(options, rerun) {
 function applyDeviceTargeting(command, adapter, options, opts) {
   const device = optionString(options, "device");
   const platformPreference = mobilePlatformPreference(options);
-  if (adapter !== "mobile") {
+  if (!getAdapterSurface(adapter).readiness.devices) {
     if (device !== void 0) {
       return {
         ok: false,