@deeeed/metamask-harness 0.17.4 → 0.17.5

package/adapters/shared/open-debug.mjs

@@ -3,10 +3,11 @@
  * open-debug.mjs — open human-facing debugger UIs for recipe runtimes.
  *
  * Mobile: Metro /open-debugger or /open-dev-menu HTTP endpoints.
- * Extension: DevTools in the slot-owned Chrome process, attached to the exact target.
+ * Extension: Chrome DevTools frontend for an extension page or service worker.
  */
 import { spawnSync } from 'node:child_process';
-import WebSocket from 'ws';
+import http from 'node:http';
+import { createRequire } from 'node:module';
 
 function usage() {
   console.error(`Usage:
@@ -97,8 +98,8 @@ async function fetchOk(url, init) {
   return response.ok;
 }
 
-async function fetchJson(url, init) {
-  const response = await fetch(url, init);
+async function fetchJson(url) {
+  const response = await fetch(url);
   if (!response.ok) {
     throw new Error(`HTTP ${response.status} for ${url}`);
   }
@@ -106,52 +107,109 @@ async function fetchJson(url, init) {
   return body;
 }
 
-function sendBrowserCommand(webSocketDebuggerUrl, method, params) {
+// Probe whether the debug server will accept a browser DevTools frontend
+// WebSocket for `targetId` under `origin`. Chrome 403s every browser Origin
+// unless the slot launched with --remote-allow-origins for it; a slot launched
+// before that flag existed fails here, so we can tell the user to relaunch
+// instead of opening a window that shows "Debugging connection was closed".
+// Transient: the socket is destroyed the instant the handshake resolves.
+function probeAttach(port, targetId, origin) {
   return new Promise((resolve) => {
-    const socket = new WebSocket(webSocketDebuggerUrl);
-    const timer = setTimeout(() => finish({ error: { message: `${method} timed out` } }), 5000);
-    const finish = (result) => {
-      clearTimeout(timer);
-      socket.close();
-      resolve(result);
-    };
-    socket.once('open', () => {
-      socket.send(JSON.stringify({
-        id: 1,
-        method,
-        params,
-      }));
+    const req = http.request({
+      host: '127.0.0.1',
+      port,
+      path: `/devtools/page/${targetId}`,
+      headers: {
+        Connection: 'Upgrade',
+        Upgrade: 'websocket',
+        'Sec-WebSocket-Version': '13',
+        'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ==',
+        Origin: origin,
+      },
     });
-    socket.on('message', (raw) => {
-      let message;
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
       try {
-        message = JSON.parse(String(raw));
+        req.destroy();
       } catch {
-        finish({ error: { message: `${method} returned a non-JSON WebSocket frame` } });
-        return;
+        // Best-effort teardown of the probe socket.
       }
-      if (message.id !== 1) return;
-      finish(message);
-    });
-    socket.once('error', () => finish({ error: { message: `${method} WebSocket failed` } }));
+      resolve(value);
+    };
+    req.on('upgrade', () => finish({ ok: true }));
+    req.on('response', (res) => finish({ ok: false, status: res.statusCode }));
+    req.on('error', (err) => finish({ ok: false, error: err.message }));
+    req.setTimeout(3000, () => finish({ ok: false, error: 'timeout' }));
+    req.end();
   });
 }
 
-async function openNativeDevtools(cdpPort, browserWebSocketUrl, target) {
-  const response = await sendBrowserCommand(browserWebSocketUrl, 'Target.openDevTools', {
-    targetId: target.id,
-    panelId: 'console',
-  });
-  if (response.error) throw new Error(response.error.message);
-  const devtoolsId = response.result?.targetId;
-  if (!devtoolsId) throw new Error('Chrome did not return a native DevTools target');
-  for (let attempt = 0; attempt < 20; attempt += 1) {
-    const targets = await fetchJson(`http://127.0.0.1:${cdpPort}/json/list`);
-    const devtools = targets.find((candidate) => candidate.id === devtoolsId);
-    if (devtools && String(devtools.url || '').startsWith('devtools://devtools/')) return devtools;
-    await new Promise((resolve) => setTimeout(resolve, 100));
+function resolveWebSocketImpl() {
+  if (typeof WebSocket === 'function') return WebSocket;
+  try {
+    const require = createRequire(import.meta.url);
+    return require(require.resolve('ws', { paths: [process.cwd()] }));
+  } catch {
+    return null;
   }
-  throw new Error('Chrome opened DevTools but did not expose its native target');
+}
+
+// Open the locally-served bundled DevTools frontend as its own window inside the
+// slot's own Chromium, via a browser-level CDP call (the Node client sends no
+// Origin header, so it is never origin-rejected). Returns the new target id.
+async function openDevtoolsWindow(browserWsUrl, url) {
+  const WebSocketImpl = resolveWebSocketImpl();
+  if (!WebSocketImpl) throw new Error('WebSocket unavailable in this Node runtime to open the DevTools window');
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocketImpl(browserWsUrl);
+    const timer = setTimeout(() => {
+      try {
+        ws.close();
+      } catch {
+        // Best-effort cleanup on timeout.
+      }
+      reject(new Error('timeout creating the DevTools window over CDP'));
+    }, 8000);
+    const onOpen = () => {
+      ws.send(JSON.stringify({
+        id: 1,
+        method: 'Target.createTarget',
+        params: { url, newWindow: true, width: 1200, height: 800 },
+      }));
+    };
+    const onMessage = (event) => {
+      const raw = event?.data ?? event;
+      let msg;
+      try {
+        msg = JSON.parse(Buffer.isBuffer(raw) ? raw.toString('utf8') : String(raw));
+      } catch {
+        return;
+      }
+      if (msg.id !== 1) return;
+      clearTimeout(timer);
+      ws.close();
+      if (msg.error) {
+        reject(new Error(msg.error.message || 'Target.createTarget failed'));
+        return;
+      }
+      resolve(msg.result?.targetId || null);
+    };
+    const onError = (err) => {
+      clearTimeout(timer);
+      reject(new Error(`browser CDP websocket error while opening DevTools: ${err?.message || err || 'unknown'}`));
+    };
+    if (typeof ws.on === 'function') {
+      ws.on('open', onOpen);
+      ws.on('message', onMessage);
+      ws.on('error', onError);
+    } else {
+      ws.addEventListener('open', onOpen);
+      ws.addEventListener('message', onMessage);
+      ws.addEventListener('error', onError);
+    }
+  });
 }
 
 // CDP-eval fallback: invoke DevSettings native module directly via the bridge
@@ -256,8 +314,7 @@ function pickExtensionTarget(targets, targetKind) {
 
   const pages = extensionTargets.filter((target) => target.type === 'page');
   return (
-    pages.find((target) => String(target.url || '').includes('/sidepanel.html'))
-    || pages.find((target) => String(target.url || '').includes('/home.html'))
+    pages.find((target) => String(target.url || '').includes('/home.html'))
     || pages.find((target) => !String(target.url || '').includes('/popup-init.html'))
     || pages[0]
     || null
@@ -270,7 +327,6 @@ async function openExtensionDevtools(cdpPort, targetKind, shouldOpen) {
     return { ok: false, adapter: 'extension', error: 'invalid-cdp-port', cdpPort };
   }
 
-  const inspectUrl = 'chrome://inspect/#devices';
   const configureHint = `127.0.0.1:${numericPort}`;
   const versionEndpoint = `http://127.0.0.1:${numericPort}/json/version`;
   const listEndpoint = `http://127.0.0.1:${numericPort}/json/list`;
@@ -286,9 +342,8 @@ async function openExtensionDevtools(cdpPort, targetKind, shouldOpen) {
       cdpPort: numericPort,
       error: 'cdp-unreachable',
       endpoint: versionEndpoint,
-      inspectUrl,
       configureHint,
-      hint: `Start the extension runtime first (mm-harness launch). Then open chrome://inspect and add ${configureHint}.`,
+      hint: 'Start the extension runtime first (mm-harness launch).',
       detail: error instanceof Error ? error.message : String(error),
     };
   }
@@ -304,9 +359,8 @@ async function openExtensionDevtools(cdpPort, targetKind, shouldOpen) {
       cdpPort: numericPort,
       error: 'cdp-list-failed',
       endpoint: listEndpoint,
-      inspectUrl,
       configureHint,
-      hint: `CDP is up but /json/list failed. Open chrome://inspect and add ${configureHint}.`,
+      hint: 'CDP is up but /json/list failed. Relaunch the runtime (mm-harness launch).',
       detail: error instanceof Error ? error.message : String(error),
     };
   }
@@ -319,80 +373,107 @@ async function openExtensionDevtools(cdpPort, targetKind, shouldOpen) {
       cdpPort: numericPort,
       error: 'cdp-list-invalid',
       endpoint: listEndpoint,
-      inspectUrl,
       configureHint,
-      hint: `Open chrome://inspect and add ${configureHint}.`,
+      hint: 'Relaunch the runtime (mm-harness launch).',
     };
   }
 
   const picked = pickExtensionTarget(targets, targetKind);
-  if (picked?.id && shouldOpen) {
-    let devtoolsTarget;
-    try {
-      if (!version.webSocketDebuggerUrl) throw new Error('Chrome did not expose its browser debugger endpoint');
-      devtoolsTarget = await openNativeDevtools(numericPort, version.webSocketDebuggerUrl, picked);
-    } catch (error) {
-      return {
-        ok: false,
-        adapter: 'extension',
-        targetKind,
-        cdpPort: numericPort,
-        error: 'debugger-open-failed',
-        endpoint: listEndpoint,
-        target: { type: picked.type, url: picked.url, title: picked.title || null },
-        hint: 'The extension target is healthy, but its debugger window could not be opened. Run mm-harness debug --no-open --json to inspect the resolved target.',
-        detail: error instanceof Error ? error.message : String(error),
-      };
-    }
+  if (!picked) {
+    return {
+      ok: false,
+      adapter: 'extension',
+      targetKind,
+      cdpPort: numericPort,
+      error: 'no-target',
+      endpoint: listEndpoint,
+      configureHint,
+      hint: 'No extension targets are registered yet. Start the runtime (mm-harness launch).',
+    };
+  }
+
+  // Locally-served bundled DevTools frontend (offline, same host:port as the ws
+  // target so its Origin is allowed). Built from the target id — Chrome omits
+  // webSocketDebuggerUrl for already-attached targets, but the id is always present.
+  const wsRef = `127.0.0.1:${numericPort}/devtools/page/${picked.id}`;
+  const devtoolsUrl = `http://127.0.0.1:${numericPort}/devtools/inspector.html?ws=${wsRef}`;
+  const targetInfo = { type: picked.type, url: picked.url, title: picked.title || null };
+
+  if (!shouldOpen) {
     return {
       ok: true,
       adapter: 'extension',
       targetKind,
-      method: 'native-devtools',
-      endpoint: devtoolsTarget.url,
+      method: 'devtools-window',
+      endpoint: devtoolsUrl,
       cdpPort: numericPort,
-      target: {
-        type: picked.type,
-        url: picked.url,
-        title: picked.title || null,
-      },
-      debuggerTargetId: devtoolsTarget.id,
-      attached: true,
-      opened: true,
+      target: targetInfo,
+      devtoolsUrl,
+      opened: false,
+      detail: 'Open action not invoked (--no-open).',
     };
   }
 
-  if (shouldOpen) return {
-    ok: false,
-    adapter: 'extension',
-    targetKind,
-    error: picked ? 'devtools-url-unavailable' : 'extension-target-unavailable',
-    endpoint: listEndpoint,
-    cdpPort: numericPort,
-    target: picked
-      ? { type: picked.type, url: picked.url, title: picked.title || null }
-      : null,
-    inspectUrl,
-    configureHint,
-    opened: false,
-    hint: picked
-      ? 'The selected extension target did not expose a DevTools URL. Relaunch it with mm-harness launch.'
-      : 'No extension target is ready. Launch it with mm-harness launch, then retry mm-harness debug.',
-  };
+  // Honest gate: confirm the debug server will accept a browser DevTools Origin
+  // before opening a window. A slot launched before --remote-allow-origins support
+  // 403s here; tell the user to relaunch rather than open a dead console.
+  const probe = await probeAttach(numericPort, picked.id, `http://127.0.0.1:${numericPort}`);
+  if (!probe.ok) {
+    return {
+      ok: false,
+      adapter: 'extension',
+      targetKind,
+      cdpPort: numericPort,
+      error: 'origin-rejected',
+      endpoint: devtoolsUrl,
+      target: targetInfo,
+      hint: 'This slot was launched before debugger support (Chrome rejects the DevTools WebSocket origin). Relaunch it: mm-harness launch',
+      detail: probe.status ? `HTTP ${probe.status}` : probe.error || 'handshake rejected',
+    };
+  }
+
+  const browserWsUrl = version?.webSocketDebuggerUrl;
+  if (!browserWsUrl) {
+    return {
+      ok: false,
+      adapter: 'extension',
+      targetKind,
+      cdpPort: numericPort,
+      error: 'no-browser-ws',
+      endpoint: devtoolsUrl,
+      target: targetInfo,
+      hint: 'CDP /json/version did not expose a browser websocket. Relaunch the runtime (mm-harness launch).',
+    };
+  }
+
+  let createdTargetId;
+  try {
+    createdTargetId = await openDevtoolsWindow(browserWsUrl, devtoolsUrl);
+  } catch (error) {
+    return {
+      ok: false,
+      adapter: 'extension',
+      targetKind,
+      cdpPort: numericPort,
+      error: 'devtools-window-failed',
+      endpoint: devtoolsUrl,
+      target: targetInfo,
+      hint: 'Could not open the DevTools window over CDP. Relaunch the runtime (mm-harness launch).',
+      detail: error instanceof Error ? error.message : String(error),
+    };
+  }
 
   return {
     ok: true,
     adapter: 'extension',
     targetKind,
-    method: picked?.devtoolsFrontendUrl ? 'devtools-frontend' : 'target-list',
-    endpoint: picked?.devtoolsFrontendUrl || listEndpoint,
+    method: 'devtools-window',
+    endpoint: devtoolsUrl,
     cdpPort: numericPort,
-    target: picked
-      ? { type: picked.type, url: picked.url, title: picked.title || null }
-      : null,
-    devtoolsUrl: picked?.devtoolsFrontendUrl || null,
-    opened: false,
-    detail: 'Open action not invoked (--no-open).',
+    target: targetInfo,
+    devtoolsUrl,
+    createdTargetId,
+    opened: true,
   };
 }
 

package/adapters/shared/resolve-farmslot-ports-core.mjs

@@ -0,0 +1,3 @@
+// Back-compat shim: the port-resolution core is now resolve-slot-ports-core.mjs.
+// Re-exports it verbatim for one release so importers of the old path keep resolving.
+export * from './resolve-slot-ports-core.mjs';

package/adapters/shared/resolve-farmslot-ports.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// Back-compat shim: this leaf is now resolve-slot-ports.mjs. Delegates to it for one
+// release so `node resolve-farmslot-ports.mjs <fn> <repo>` keeps working (the new CLI
+// reads the same argv positions on import).
+import './resolve-slot-ports.mjs';

package/adapters/shared/resolve-farmslot-ports.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Back-compat shim: this wrapper is now resolve-slot-ports.sh. Sources it for one
+# release so old callers keep the same sourced function names (including the
+# resolve_farmslot_ports_by_repo alias defined there).
+_SHIM_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck disable=SC1091
+. "$_SHIM_DIR/resolve-slot-ports.sh"

package/adapters/shared/resolve-slot-ports-core.mjs

@@ -276,8 +276,14 @@ export function resolveMobileRuntimePorts(repo) {
   );
 }
 
+// Back-compat: the previous name for resolveSlotPortsByRepo, kept as an alias for
+// one release so existing importers keep resolving.
+export const resolveFarmslotPortsByRepo = resolveSlotPortsByRepo;
+
 export const cliFns = {
   resolve_slot_ports_by_repo: resolveSlotPortsByRepo,
+  // Back-compat cli key for one release.
+  resolve_farmslot_ports_by_repo: resolveSlotPortsByRepo,
   resolve_default_extension_ports: resolveDefaultExtensionPorts,
   resolve_extension_runtime_context: resolveExtensionRuntimeContext,
   resolve_extension_slot_ports: (repo) => formatExtensionSlotPorts(repo) || null,

package/adapters/shared/resolve-slot-ports.sh

@@ -20,6 +20,11 @@ resolve_slot_ports_by_repo() {
   _resolve_ports_cli resolve_slot_ports_by_repo "$1"
 }
 
+# Back-compat alias for the previous function name (one release).
+resolve_farmslot_ports_by_repo() {
+  resolve_slot_ports_by_repo "$1"
+}
+
 infer_extension_slot_suffix() {
   local repo="$1" base
   base="$(basename "$repo")"
@@ -48,7 +53,7 @@ apply_extension_slot_ports() {
   repo="$(cd "$repo" && pwd)"
   ctx_file="$repo/$runtime_rel/agentic-runtime.json"
   if [ -f "$ctx_file" ]; then
-    export RECIPE_RUNTIME_CONTEXT="$ctx_file"
+    RECIPE_RUNTIME_CONTEXT="$ctx_file"
   else
     unset RECIPE_RUNTIME_CONTEXT
   fi
@@ -106,4 +111,4 @@ apply_resolved_mobile_ports() {
         ;;
     esac
   done <<< "$resolved"
-}
+}

package/bin/mm-harness

@@ -50,13 +50,6 @@ if [ -n "${MM_HARNESS_BIN:-}" ]; then
   fi
 fi
 
-# Internal executable identity (not part of the public env surface): the CLI
-# embeds this in emitted recovery commands so they run verbatim even when
-# mm-harness is not on PATH (task-local installs). Set AFTER the MM_HARNESS_BIN
-# delegation above so the final executable entered always overwrites any
-# inherited/stale value with its own resolved self path.
-export MM_HARNESS_EXECUTABLE="$SCRIPT_DIR/$(basename "$SOURCE")"
-
 ENTRY_TS="$RUNNER_DIR/src/mm-harness-cli.ts"
 ENTRY_DIST="$RUNNER_DIR/dist/mm-harness-cli.js"
 

package/dist/adapters/extension/harness-freshness.js

@@ -0,0 +1,39 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { recipeHarnessPath, runnerDir } from "../../paths.js";
+async function ensureExtensionHarnessFresh(target) {
+  if (!fs.existsSync(path.join(target, "package.json"))) return;
+  let current;
+  try {
+    const mod = await import(pathToFileURL(path.join(runnerDir, "adapters/shared/harness-source-fingerprint.mjs")).href);
+    current = mod.harnessSourceFingerprint(runnerDir);
+  } catch {
+    return;
+  }
+  const manifestPath = recipeHarnessPath(target, "extension", "manifest.json");
+  const installed = readInstalledFingerprint(manifestPath);
+  if (installed === current) return;
+  const reason = installed === null ? "harness not installed" : "runner changed";
+  try {
+    execFileSync(process.execPath, [path.join(runnerDir, "adapters/extension/inject.mjs"), "--target", target], {
+      stdio: ["ignore", "ignore", "inherit"]
+    });
+    console.error(`\u2192 refreshed extension harness overlay (${reason})`);
+  } catch (error) {
+    const detail = error instanceof Error ? `: ${error.message}` : "";
+    throw new Error(`could not refresh the extension harness overlay (${reason})${detail}`);
+  }
+}
+function readInstalledFingerprint(manifestPath) {
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    return typeof manifest.sourceFingerprint === "string" ? manifest.sourceFingerprint : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  ensureExtensionHarnessFresh
+};

package/dist/adapters/extension/runtime-decision.js

@@ -163,80 +163,18 @@ function runtimeDistCheck(target) {
   let output;
   try {
     output = execFileSync("rsync", [
-      "-rni",
+      "-rnic",
       "--exclude",
       "_metadata",
       "--out-format=%n",
       `${dist}${path.sep}`,
       `${runtimeDist}${path.sep}`
     ], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      try {
-        const modified2 = filesystemSnapshotDiff(dist, runtimeDist).filter((relative) => !slotTitleOnlyDifference(dist, runtimeDist, relative)).slice(0, 10);
-        return modified2.length > 0 ? { status: "stale", comparison: "filesystem-quick", modified: modified2 } : { status: "fresh", comparison: "filesystem-quick" };
-      } catch (fallbackError) {
-        return {
-          status: "unknown",
-          error: `snapshot comparison failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`
-        };
-      }
-    }
-    const status = error.status;
-    return {
-      status: "unknown",
-      error: `rsync snapshot comparison failed${typeof status === "number" ? ` with exit ${status}` : ""}`
-    };
-  }
-  const modified = output.split("\n").map((line) => line.trim()).filter(Boolean).filter((relative) => !slotTitleOnlyDifference(dist, runtimeDist, relative)).slice(0, 10);
-  return modified.length > 0 ? { status: "stale", comparison: "rsync-quick", modified } : { status: "fresh", comparison: "rsync-quick" };
-}
-function slotTitleOnlyDifference(dist, runtimeDist, relative) {
-  if (relative !== "home.html" && relative !== "sidepanel.html") return false;
-  try {
-    const normalize = (source) => source.replace(
-      /<title>([^<]*)<\/title>/iu,
-      (_match, title) => `<title>${String(title || "MetaMask").replace(/^.+?\s+[—–-]\s+/u, "") || "MetaMask"}</title>`
-    );
-    return normalize(fs.readFileSync(path.join(dist, relative), "utf8")) === normalize(fs.readFileSync(path.join(runtimeDist, relative), "utf8"));
   } catch {
-    return false;
+    return { status: "stale", modified: ["<snapshot comparison failed>"] };
   }
-}
-function filesystemSnapshotDiff(source, snapshot) {
-  const sourceEntries = snapshotEntries(source);
-  const snapshotEntriesByPath = snapshotEntries(snapshot);
-  const paths = [.../* @__PURE__ */ new Set([...sourceEntries.keys(), ...snapshotEntriesByPath.keys()])].sort();
-  return paths.filter((relative) => {
-    const left = sourceEntries.get(relative);
-    const right = snapshotEntriesByPath.get(relative);
-    return left === void 0 || right === void 0 || JSON.stringify(left) !== JSON.stringify(right);
-  });
-}
-function snapshotEntries(root) {
-  const entries = /* @__PURE__ */ new Map();
-  const walk2 = (directory) => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      if (entry.name === "_metadata") continue;
-      const absolute = path.join(directory, entry.name);
-      const relative = path.relative(root, absolute);
-      const stat = fs.lstatSync(absolute);
-      if (entry.isDirectory()) {
-        entries.set(relative, { type: "directory" });
-        walk2(absolute);
-      } else if (entry.isSymbolicLink()) {
-        entries.set(relative, { type: "symlink", link: fs.readlinkSync(absolute) });
-      } else if (entry.isFile()) {
-        entries.set(relative, {
-          type: "file",
-          size: stat.size,
-          mtimeSeconds: Math.floor(stat.mtimeMs / 1e3)
-        });
-      }
-    }
-  };
-  walk2(root);
-  return entries;
+  const modified = output.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, 10);
+  return modified.length > 0 ? { status: "stale", modified } : { status: "fresh" };
 }
 function distCheck(target) {
   const manifestPath = path.join(target, "dist/chrome/manifest.json");
@@ -346,13 +284,6 @@ async function decideExtensionReadiness(target, options = {}) {
       reasons: [dist.reason === "uncommitted-source" ? `Uncommitted source since the build (${dist.modified?.length ?? 0} file(s)); rebuild.` : `dist git id ${dist.distGitId} != HEAD ${dist.head}; rebuild.`],
       actions: buildAction(resolved, false)
     },
-    {
-      when: runtimeDist.status === "unknown",
-      decision: "blocked",
-      reasonCode: "runtime-dist-check-failed",
-      reasons: [runtimeDist.error ?? "The loaded runtime snapshot could not be compared with dist/chrome."],
-      actions: []
-    },
     {
       when: runtimeDist.status !== "fresh",
       decision: "relaunch",

package/dist/adapters/extension/surface.js

@@ -65,12 +65,11 @@ const extensionSurface = {
     return [
       { label: "webpack", path: recipeRuntimePath(target, "webpack.log") },
       { label: "watcher", path: recipeRuntimePath(target, "recipe-harness-webpack.log") },
-      { label: "rebuild", path: recipeRuntimePath(target, "rebuild.log") },
-      { label: "dapp", path: recipeRuntimePath(target, "dapp-console.log") }
+      { label: "rebuild", path: recipeRuntimePath(target, "rebuild.log") }
     ];
   },
   appLogSource(target) {
-    return { label: "extension", path: recipeRuntimePath(target, "extension-console.log") };
+    return { label: "app", path: recipeRuntimePath(target, "extension-console.log") };
   },
   hints: {
     launch: "mm-harness launch",