@deeeed/metamask-harness 0.82.0 → 0.83.0

package/dist/commands/core-readiness.js

@@ -47,13 +47,6 @@ function coreDependencyBlock(target) {
   }
   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] });
@@ -75,6 +68,5 @@ function shellQuote(value) {
   return `'${value.replace(/'/gu, `'\\''`)}'`;
 }
 export {
-  coreDependencyBlock,
-  corePnpNodeOptions
+  coreDependencyBlock
 };

package/dist/performance-observation.js

@@ -1,11 +1,17 @@
+import { createRequire } from "node:module";
 import path from "node:path";
 import { promisify } from "node:util";
 import { gzip } from "node:zlib";
 import { getAdapterSurface } from "./adapters/surface.js";
-import { createExtensionPerformanceBackend } from "./adapters/extension/performance-observer.js";
-import { TRACE_KINDS } from "./adapters/performance/cdp-trace.js";
-import { summarizeFrames } from "@farmslot/adapter-rn";
-import { summarizeJavaScriptTasks } from "./adapters/performance/js-task-metrics.js";
+import { resolveExtensionId } from "./adapters/extension/extension-id.js";
+import {
+  TRACE_KINDS,
+  TRACE_MARKER_PREFIX
+} from "./adapters/performance/trace-kinds.js";
+import {
+  summarizeFrames,
+  summarizeJavaScriptTasks
+} from "@farmslot/recipe-runner/runtime/cdp-trace";
 import {
   indexArtifactManifest,
   readContainedJsonArtifact,
@@ -512,7 +518,24 @@ function unavailableCapture(session, window, reason) {
   );
 }
 async function createExtensionPerformanceObserver(target, env) {
-  return createExtensionPerformanceBackend(extensionCdpPort(env), target);
+  const cdpPort = extensionCdpPort(env);
+  const extensionId = (await resolveExtensionId(target, { cdpPort })).extensionId;
+  if (!extensionId) {
+    throw new Error("Extension performance observation could not resolve the MetaMask extension id.");
+  }
+  const { createExtensionPerformanceBackend } = createRequire(import.meta.url)(
+    "@farmslot/adapter-web/performance-observer"
+  );
+  return createExtensionPerformanceBackend({
+    cdpPort,
+    extensionId,
+    uiPaths: ["/home.html", "/sidepanel.html"],
+    kind: TRACE_KINDS.extension,
+    platform: "extension",
+    markerPrefix: TRACE_MARKER_PREFIX,
+    connectTimeoutMs: 1e4,
+    commandTimeoutMs: 1e4
+  });
 }
 function extensionCdpPort(env) {
   const port = Number(env.CDP_PORT ?? env.RECIPE_CDP_PORT);

package/library/actions/core/perps/_controller.mjs

@@ -904,6 +904,16 @@ export async function runAdapter(callback) {
       // Surface the failure; still tear down so a half-open WebSocket from a
       // failed write doesn't leave the process wedged open.
       process.stderr.write(`[core/perps] adapter failed: ${fmtError(error)}\n`);
+      // A module the checkout cannot resolve is its environment (a partial
+      // workspace build), not app logic: say so on its own line, with the
+      // build step, for the runner's environment classification to match.
+      if (error?.code === 'ERR_MODULE_NOT_FOUND' || error?.code === 'MODULE_NOT_FOUND') {
+        const root = input.context?.projectRoot ?? process.cwd();
+        const missing = error.url ?? String(error.message ?? '').split('\n')[0];
+        process.stderr.write(
+          `[core/perps] environment: cannot resolve ${missing}\n  Next: cd '${root.replace(/'/gu, `'\\''`)}' && yarn build\n`,
+        );
+      }
     }
   } finally {
     await disconnectController(exitCode);

package/library/actions/extension/wallet/import.mjs

@@ -100,6 +100,23 @@ async function unlockProfile(page, credentials, timeoutMs) {
   await waitForSelectorToDisappear(page, SELECTORS.unlockPassword, timeoutMs);
 }
 
+// A locked profile is unlocked before the account proof. A fresh profile can
+// also lock right after onboarding while the sidepanel attaches, stranding the
+// proof on #/unlock: that relock is recovered once with the fixture password and
+// reported as relockRecovered; a further lock fails with the route error.
+async function ensureUnlockedSelectedAccount(page, credentials, timeoutMs) {
+  if (await hasVisibleSelector(page, SELECTORS.unlockPassword)) await unlockProfile(page, credentials, timeoutMs);
+  try {
+    const visibleSession = await ensureVisibleSelectedAccount(page, credentials.expectedAddress, timeoutMs);
+    return { ...visibleSession, relockRecovered: false };
+  } catch (error) {
+    if (!(await hasVisibleSelector(page, SELECTORS.unlockPassword))) throw error;
+    await unlockProfile(page, credentials, timeoutMs);
+    const visibleSession = await ensureVisibleSelectedAccount(page, credentials.expectedAddress, timeoutMs);
+    return { ...visibleSession, relockRecovered: true };
+  }
+}
+
 async function importThroughUi(page, input, timeoutMs) {
   const credentials = await resolveWalletImportCredentials(input);
   const metametricsEnabled = input.node?.metametrics === true || input.node?.metametrics === 'true';
@@ -149,7 +166,7 @@ async function importThroughUi(page, input, timeoutMs) {
   await waitForSelector(page, SELECTORS.complete, timeoutMs);
   await page.click(SELECTORS.complete);
 
-  const visibleSession = await ensureVisibleSelectedAccount(page, credentials.expectedAddress, timeoutMs);
+  const visibleSession = await ensureUnlockedSelectedAccount(page, credentials, timeoutMs);
   return { credentials, visibleSession, metametricsEnabled };
 }
 
@@ -168,9 +185,7 @@ runAdapter((input) => withExtensionPage(input, async (page) => {
     if (!onboarding) {
       const credentials = await resolveWalletImportCredentials(input);
       const completionTriggered = await dismissVisibleOnboardingCompletion(page);
-      const locked = await hasVisibleSelector(page, SELECTORS.unlockPassword);
-      if (locked) await unlockProfile(page, credentials, timeoutMs);
-      const visibleSession = await ensureVisibleSelectedAccount(page, credentials.expectedAddress, timeoutMs);
+      const visibleSession = await ensureUnlockedSelectedAccount(page, credentials, timeoutMs);
       return {
         action: input.action,
         method: 'ui-visible-session',
@@ -191,6 +206,7 @@ runAdapter((input) => withExtensionPage(input, async (page) => {
       selectedIdentitySha256: imported.visibleSession.selectedIdentitySha256,
       selectedAddressMatched: imported.visibleSession.selectedAddressMatched,
       selectionPerformed: imported.visibleSession.selectionPerformed,
+      relockRecovered: imported.visibleSession.relockRecovered,
       completedOnboarding: true,
       metametricsEnabled: imported.metametricsEnabled,
       interests: [],
@@ -213,6 +229,7 @@ runAdapter((input) => withExtensionPage(input, async (page) => {
       selectedIdentitySha256: imported.visibleSession.selectedIdentitySha256,
       selectedAddressMatched: imported.visibleSession.selectedAddressMatched,
       selectionPerformed: imported.visibleSession.selectionPerformed,
+      relockRecovered: imported.visibleSession.relockRecovered,
       completedOnboarding: true,
       metametricsEnabled: imported.metametricsEnabled,
       interests: [],

package/library/actions/extension/wallet/visible-session.mjs

@@ -44,7 +44,7 @@ async function currentRoute(page, deadline) {
   return route.replace(/0x[0-9a-f]{40}/giu, '<redacted-address>').slice(0, 200);
 }
 
-async function routeError(page, message, deadline) {
+async function routeError(page, message, deadline, cause) {
   let route = '<deadline-expired>';
   if (Date.now() < deadline) {
     try {
@@ -53,7 +53,35 @@ async function routeError(page, message, deadline) {
       route = '<unavailable>';
     }
   }
-  return new Error(`${message} (route ${JSON.stringify(route)}).`);
+  const detail = cause
+    ? `; last input error: ${String(cause.message ?? cause).replace(/0x[0-9a-f]{40}/giu, '<redacted-address>').slice(0, 200)}`
+    : '';
+  return new Error(`${message} (route ${JSON.stringify(route)})${detail}.`);
+}
+
+// Entry can fail transiently while the account list settles after onboarding,
+// so it is retried in place until the shared deadline; leaving the list (a
+// lock, a redirect) fails at once with the last input error. Callers still
+// assert the rendered result, so a retry can never pass a wrong account.
+async function enterAccountSearch(page, value, deadline, message) {
+  let lastError;
+  while (Date.now() <= deadline) {
+    try {
+      await withinDeadline(page.setInput(ACCOUNT_SEARCH, value), deadline);
+      return;
+    } catch (error) {
+      lastError = error;
+    }
+    let route;
+    try {
+      route = await currentRoute(page, deadline);
+    } catch {
+      break;
+    }
+    if (route !== '#/account-list') break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw await routeError(page, message, deadline, lastError);
 }
 
 async function visibleAccountMatch(page, deadline) {
@@ -140,11 +168,7 @@ async function openAccountList(page, deadline) {
 
 async function proveAddressSearchControl(page, expectedAddress, deadline) {
   const probeAddress = accountProbeAddress(expectedAddress);
-  try {
-    await withinDeadline(page.setInput(ACCOUNT_SEARCH, probeAddress), deadline);
-  } catch {
-    throw await routeError(page, 'Visible wallet account search could not enter the alternate-address control', deadline);
-  }
+  await enterAccountSearch(page, probeAddress, deadline, 'Visible wallet account search could not enter the alternate-address control');
   let consecutiveEmpty = 0;
   while (Date.now() <= deadline) {
     let observed;
@@ -166,11 +190,7 @@ async function proveAddressSearchControl(page, expectedAddress, deadline) {
 
 async function queryExpectedAccount(page, expectedAddress, deadline, requireSelected) {
   await proveAddressSearchControl(page, expectedAddress, deadline);
-  try {
-    await withinDeadline(page.setInput(ACCOUNT_SEARCH, expectedAddress), deadline);
-  } catch {
-    throw await routeError(page, 'Visible wallet account search could not enter the derived release identity', deadline);
-  }
+  await enterAccountSearch(page, expectedAddress, deadline, 'Visible wallet account search could not enter the derived release identity');
   let observed;
   while (Date.now() <= deadline) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.82.0",
+  "version": "0.83.0",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"
@@ -21,14 +21,15 @@
     "check:syntax": "find . -name '*.mjs' -print0 | xargs -0 -n1 node --check"
   },
   "dependencies": {
-    "@farmslot/adapter-rn": "0.17.1",
-    "@farmslot/adapter-sdk": "0.5.0",
-    "@farmslot/adapter-web": "0.3.1",
+    "@farmslot/adapter-node": "0.1.2",
+    "@farmslot/adapter-rn": "0.18.0",
+    "@farmslot/adapter-sdk": "0.6.0",
+    "@farmslot/adapter-web": "0.4.1",
     "@farmslot/agent-runtime": "0.17.0",
     "@farmslot/handoff": "^0.3.1",
     "@farmslot/protocol": "0.34.0",
-    "@farmslot/recipe-cli": "0.6.0",
-    "@farmslot/recipe-runner": "0.25.0",
+    "@farmslot/recipe-cli": "0.8.0",
+    "@farmslot/recipe-runner": "0.26.0",
     "agent-device": "0.19.3",
     "commander": "^12.0.0",
     "esbuild": "0.28.1",

package/dist/adapters/core/live-script-env.js

@@ -1,36 +0,0 @@
-import { existsSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
-import { corePnpNodeOptions } from "../../commands/core-readiness.js";
-const CORE_WORKSPACE_PACKAGES = [
-  "@metamask/base-controller",
-  "@metamask/messenger",
-  "@metamask/controller-utils",
-  "@metamask/keyring-controller"
-];
-async function coreLiveScriptEnv(projectRoot, tempDir) {
-  const paths = {};
-  for (const pkg of CORE_WORKSPACE_PACKAGES) {
-    const packageDir = path.join(projectRoot, "packages", pkg.replace("@metamask/", ""));
-    const distEntry = path.join(packageDir, "dist/index.cjs");
-    if (existsSync(distEntry)) continue;
-    const srcDir = path.join(packageDir, "src");
-    if (!existsSync(path.join(srcDir, "index.ts"))) continue;
-    paths[pkg] = [path.join(srcDir, "index.ts")];
-    paths[`${pkg}/*`] = [path.join(srcDir, "*")];
-  }
-  if (Object.keys(paths).length === 0) return {};
-  const tsconfigPath = path.join(tempDir, "core-adapter.tsconfig.json");
-  await writeFile(
-    tsconfigPath,
-    `${JSON.stringify({ compilerOptions: { baseUrl: projectRoot, paths } }, null, 2)}
-`
-  );
-  return {
-    TSX_TSCONFIG_PATH: tsconfigPath,
-    NODE_OPTIONS: corePnpNodeOptions(projectRoot, process.env.NODE_OPTIONS)
-  };
-}
-export {
-  coreLiveScriptEnv
-};

package/dist/adapters/extension/browser-cdp.js

@@ -1,174 +0,0 @@
-import { WebSocket } from "ws";
-import { withTimeout } from "../../async.js";
-const DEFAULT_TIMEOUT_MS = 1e4;
-async function createBrowserCdpClient(cdpPort) {
-  if (!Number.isInteger(cdpPort) || cdpPort <= 0) {
-    throw new Error("Extension CDP requires a valid port.");
-  }
-  const version = asRecord(
-    await fetchJson(`http://127.0.0.1:${cdpPort}/json/version`)
-  );
-  const webSocketUrl = String(version.webSocketDebuggerUrl ?? "");
-  if (!webSocketUrl) {
-    throw new Error("Extension browser CDP WebSocket is unavailable.");
-  }
-  const socket = new WebSocket(webSocketUrl);
-  await waitForOpen(socket);
-  let nextId = 0;
-  const pending = /* @__PURE__ */ new Map();
-  const handlers = /* @__PURE__ */ new Set();
-  const closeHandlers = /* @__PURE__ */ new Set();
-  socket.on("message", (data) => {
-    let message;
-    try {
-      message = JSON.parse(String(data));
-    } catch {
-      return;
-    }
-    if (message.id && pending.has(message.id)) {
-      const command = pending.get(message.id);
-      pending.delete(message.id);
-      if (!command) return;
-      clearTimeout(command.timer);
-      if (message.error) {
-        command.reject(
-          new Error(
-            String(message.error.message ?? "Extension CDP command failed")
-          )
-        );
-      } else {
-        command.resolve(message.result ?? {});
-      }
-      return;
-    }
-    for (const handler of handlers) handler(message);
-  });
-  socket.on("close", () => {
-    for (const command of pending.values()) {
-      clearTimeout(command.timer);
-      command.reject(new Error("Extension browser CDP connection closed"));
-    }
-    pending.clear();
-    handlers.clear();
-    for (const handler of closeHandlers) handler();
-    closeHandlers.clear();
-  });
-  return {
-    send(method, params = {}, sessionId, timeoutMs = DEFAULT_TIMEOUT_MS) {
-      return new Promise((resolve, reject) => {
-        const id = ++nextId;
-        const timer = setTimeout(() => {
-          pending.delete(id);
-          reject(new Error(`Extension CDP command timed out: ${method}`));
-        }, timeoutMs);
-        pending.set(id, { resolve, reject, timer });
-        socket.send(
-          JSON.stringify({
-            id,
-            method,
-            params,
-            ...sessionId ? { sessionId } : {}
-          })
-        );
-      });
-    },
-    onMessage(handler) {
-      handlers.add(handler);
-      return () => handlers.delete(handler);
-    },
-    onClose(handler) {
-      closeHandlers.add(handler);
-      return () => closeHandlers.delete(handler);
-    },
-    close() {
-      socket.close();
-    }
-  };
-}
-async function fetchCdpJson(cdpPort, path = "/json") {
-  return fetchJson(`http://127.0.0.1:${cdpPort}${path}`);
-}
-function asBrowserCdpTarget(value) {
-  const target = asRecord(value);
-  const targetId = String(target.targetId ?? target.id ?? "");
-  const type = String(target.type ?? "");
-  const url = String(target.url ?? "");
-  return targetId && type && url ? { targetId, type, url } : null;
-}
-function extensionIdFromCdpTargets(value) {
-  const targets = Array.isArray(value) ? value : [];
-  for (const candidate of targets) {
-    const target = asBrowserCdpTarget(candidate);
-    if (!target) continue;
-    try {
-      const url = new URL(target.url);
-      if (url.protocol === "chrome-extension:" && url.hostname) {
-        return url.hostname;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function selectExtensionUiTarget(value, extensionId) {
-  const targets = Array.isArray(value) ? value : [];
-  const candidates = targets.map(asBrowserCdpTarget).filter((candidate) => {
-    if (!candidate || !["page", "other"].includes(candidate.type)) return false;
-    try {
-      const url = new URL(candidate.url);
-      return url.protocol === "chrome-extension:" && url.hostname === extensionId;
-    } catch {
-      return false;
-    }
-  });
-  const matchingPath = (target, pathname) => {
-    try {
-      return new URL(target.url).pathname === pathname;
-    } catch {
-      return false;
-    }
-  };
-  const home = candidates.filter((target) => matchingPath(target, "/home.html"));
-  if (home.length > 0) return home.length === 1 ? home[0] : null;
-  const sidepanel = candidates.filter(
-    (target) => matchingPath(target, "/sidepanel.html")
-  );
-  return sidepanel.length === 1 ? sidepanel[0] : null;
-}
-async function fetchJson(url) {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Extension CDP returned HTTP ${response.status}.`);
-  }
-  return response.json();
-}
-function waitForOpen(socket) {
-  const onOpen = (resolve) => () => resolve();
-  let openHandler;
-  let errorHandler;
-  const opened = new Promise((resolve, reject) => {
-    openHandler = onOpen(resolve);
-    errorHandler = reject;
-    socket.once("open", openHandler);
-    socket.once("error", errorHandler);
-  });
-  return withTimeout(opened, {
-    message: "Extension browser CDP connection timed out.",
-    timeoutMs: DEFAULT_TIMEOUT_MS,
-    onTimeout: () => socket.close()
-  }).finally(() => {
-    if (openHandler) socket.off("open", openHandler);
-    if (errorHandler) socket.off("error", errorHandler);
-  });
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-export {
-  asBrowserCdpTarget,
-  createBrowserCdpClient,
-  extensionIdFromCdpTargets,
-  fetchCdpJson,
-  selectExtensionUiTarget
-};

package/dist/adapters/extension/performance-observer.js

@@ -1,75 +0,0 @@
-import {
-  createCdpTraceCollector
-} from "../performance/cdp-trace.js";
-import {
-  createBrowserCdpClient,
-  fetchCdpJson,
-  selectExtensionUiTarget
-} from "./browser-cdp.js";
-import { resolveExtensionId } from "./extension-id.js";
-async function createExtensionPerformanceBackend(cdpPort, target) {
-  const extensionId = (await resolveExtensionId(target, { cdpPort })).extensionId;
-  if (!extensionId) {
-    throw new Error("Extension performance observation could not resolve the MetaMask extension id.");
-  }
-  const uiTarget = selectExtensionUiTarget(
-    await fetchCdpJson(cdpPort),
-    extensionId
-  );
-  if (!uiTarget) {
-    throw new Error("Extension performance observation requires an open MetaMask UI target.");
-  }
-  const browser = await createBrowserCdpClient(cdpPort);
-  const attached = asRecord(
-    await browser.send(
-      "Target.attachToTarget",
-      { targetId: uiTarget.targetId, flatten: true },
-      void 0,
-      1e4
-    )
-  );
-  const sessionId = String(attached.sessionId ?? "");
-  if (!sessionId) {
-    browser.close();
-    throw new Error("Extension performance observation could not attach to the MetaMask UI target.");
-  }
-  const client = browserTraceClient(browser);
-  return createCdpTraceCollector(client, "extension", async (name) => {
-    const before = Date.now();
-    await browser.send(
-      "Runtime.evaluate",
-      {
-        expression: `performance.mark(${JSON.stringify(name)})`,
-        returnByValue: true
-      },
-      sessionId,
-      1e4
-    );
-    const after = Date.now();
-    return {
-      hostEpochMs: (before + after) / 2,
-      uncertaintyMs: (after - before) / 2
-    };
-  });
-}
-function browserTraceClient(browser) {
-  return {
-    send(method, params = {}, timeoutMs) {
-      return browser.send(method, params, void 0, timeoutMs);
-    },
-    on(method, handler) {
-      return browser.onMessage((message) => {
-        if (message.method === method) handler(message.params ?? {});
-      });
-    },
-    close() {
-      browser.close();
-    }
-  };
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-export {
-  createExtensionPerformanceBackend
-};