@deeeed/metamask-harness 0.14.2 → 0.14.4

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 0.14.4 - 2026-07-09
+
+### Fixed
+- Include the new extension viewer cleanup scripts in the adapter manifest so published packages pass adapter-surface validation.
+
+## 0.14.3 - 2026-07-09
+
+### Fixed
+- Extension `status` and `doctor` now accept a sidepanel-only live runtime, matching `run`/`call` health checks instead of requiring a fullscreen `home.html` tab after `launch --sidepanel`.
+- Extension sidepanel launch waits longer for Chrome to expose the `sidepanel.html` CDP target, avoiding false failures after Chrome accepts the open request.
+- Extension tmux viewers are opened only in the run-owned tmux session and are cleaned by `mm-harness stop`, preventing stale `webpack-*`/`console-*` windows from leaking across slots.
+- Extension clean relaunch recognizes prior same-checkout Chrome instances loaded from both timestamped harness snapshots and `temp/recipe/runtime/runtime-dist`, while still refusing foreign CDP owners.
+
 ## 0.14.2 - 2026-07-09
 
 ### Fixed

package/adapters/extension/inject.mjs

@@ -104,6 +104,7 @@ copyFile(path.join(runnerDir, 'adapters/extension/console-tail.mjs'), path.join(
 copyFile(path.join(runnerDir, 'adapters/extension/launch.sh'), path.join(harnessDir, 'scripts/launch.sh'));
 copyFile(path.join(runnerDir, 'adapters/extension/live.sh'), path.join(harnessDir, 'scripts/live.sh'));
 copyFile(path.join(runnerDir, 'adapters/extension/start-watch.sh'), path.join(harnessDir, 'scripts/start-watch.sh'));
+copyFile(path.join(runnerDir, 'adapters/extension/stop-viewers.sh'), path.join(harnessDir, 'scripts/stop-viewers.sh'));
 copyFile(path.join(runnerDir, 'adapters/extension/snapshot-dist.sh'), path.join(harnessDir, 'scripts/snapshot-dist.sh'));
 copyFile(path.join(runnerDir, 'adapters/extension/pin-remote-flags.cjs'), path.join(harnessDir, 'scripts/pin-remote-flags.cjs'));
 copyFile(path.join(runnerDir, 'adapters/extension/seed-fixture.sh'), path.join(harnessDir, 'scripts/seed-fixture.sh'));
@@ -126,6 +127,7 @@ copyFile(path.join(runnerDir, 'adapters/shared/resolve-farmslot-ports-core.mjs')
 copyFile(path.join(runnerDir, 'adapters/shared/path-defaults.json'), path.join(harnessDir, 'scripts/lib/path-defaults.json'));
 copyFile(path.join(runnerDir, 'adapters/shared/json-field.sh'), path.join(harnessDir, 'scripts/lib/json-field.sh'));
 copyFile(path.join(runnerDir, 'adapters/shared/tmux-session.sh'), path.join(harnessDir, 'scripts/lib/tmux-session.sh'));
+copyFile(path.join(runnerDir, 'adapters/shared/tmux-viewer.sh'), path.join(harnessDir, 'scripts/lib/tmux-viewer.sh'));
 copyFile(path.join(runnerDir, 'adapters/shared/log-tui.mjs'), path.join(harnessDir, 'scripts/lib/log-tui.mjs'));
 copyFile(path.join(runnerDir, 'adapters/extension/lib/extension-id.cjs'), path.join(harnessDir, 'scripts/lib/extension-id.cjs'));
 makeExecutableTree(path.join(harnessDir, 'scripts'));

package/adapters/extension/launch-browser.cjs

@@ -64,7 +64,7 @@ fs.mkdirSync(path.dirname(args['chrome-pid']), { recursive: true });
 // else is a browser this harness did not launch (possibly the user's personal
 // Chrome), so we refuse rather than kill it or attach to it.
 const listenerPids = cdpListenerPids(cdpPort);
-const foreignPids = listenerPids.filter((pid) => !processLoadsProfile(pid, args.profile));
+const foreignPids = listenerPids.filter((pid) => !processIsOwnedHarnessBrowser(pid, args.profile, args['extension-dir']));
 if (foreignPids.length > 0) {
   throw new Error(
     `Refusing to launch on CDP port ${cdpPort}: it is held by a browser this harness did not launch (pid ${foreignPids.join(', ')}). ` +
@@ -73,7 +73,7 @@ if (foreignPids.length > 0) {
 }
 const ownedPids = new Set(listenerPids);
 const previousPid = readPidFile(args['chrome-pid']);
-if (previousPid !== null && processLoadsProfile(previousPid, args.profile)) ownedPids.add(previousPid);
+if (previousPid !== null && processIsOwnedHarnessBrowser(previousPid, args.profile, args['extension-dir'])) ownedPids.add(previousPid);
 terminatePids([...ownedPids]);
 if (args['reset-profile'] !== undefined) {
   fs.rmSync(args.profile, { recursive: true, force: true });
@@ -164,16 +164,35 @@ function assertIsolatedProfile(profile) {
 // Proof of ownership: a process is ours iff its command line loads the exact
 // --user-data-dir we launch with. If the process can't be inspected we treat it
 // as NOT ours (fail safe — never assume ownership of an opaque process).
-function processLoadsProfile(pid, profile) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
+function processIsOwnedHarnessBrowser(pid, profile, extensionDir) {
+  const command = processCommand(pid);
+  if (!command) return false;
+  if (command.includes(`--user-data-dir=${profile}`)) return true;
+  const ownerRoot = harnessOwnerRootFromExtensionDir(extensionDir);
+  return Boolean(ownerRoot && command.includes(`--load-extension=${ownerRoot}`));
+}
+
+function harnessOwnerRootFromExtensionDir(extensionDir) {
+  const resolved = path.resolve(extensionDir);
+  for (const marker of [
+    `${path.sep}temp${path.sep}recipe${path.sep}harness${path.sep}extension${path.sep}live${path.sep}`,
+    `${path.sep}temp${path.sep}recipe${path.sep}runtime${path.sep}runtime-dist`,
+  ]) {
+    const markerIndex = resolved.indexOf(marker);
+    if (markerIndex !== -1) return resolved.slice(0, markerIndex + marker.length);
+  }
+  return null;
+}
+
+function processCommand(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return null;
   try {
-    const command = execFileSync('ps', ['-ww', '-o', 'command=', '-p', String(pid)], {
+    return execFileSync('ps', ['-ww', '-o', 'command=', '-p', String(pid)], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
     });
-    return command.includes(`--user-data-dir=${profile}`);
   } catch {
-    return false;
+    return null;
   }
 }
 

package/adapters/extension/launch.sh

@@ -119,21 +119,19 @@ fi
 # tabs. Skipped silently when there is no tmux session or CDP (headless/CI), so
 # it never affects the launch result.
 if [ "$status" = "pass" ] && [ -n "$CDP_PORT" ] && command -v tmux >/dev/null 2>&1; then
-  console_session="${RECIPE_TMUX_SESSION:-}"
-  if [ -z "$console_session" ] && [[ "$(basename "$TARGET")" =~ -([0-9]+)$ ]]; then
-    console_session="mme-${BASH_REMATCH[1]}"
-  fi
+  for _tv_src in "$SCRIPT_DIR/lib/tmux-viewer.sh" "$SCRIPT_DIR/../shared/tmux-viewer.sh"; do
+    # shellcheck disable=SC1091
+    [ -f "$_tv_src" ] && { . "$_tv_src"; break; }
+  done
+  unset _tv_src
   console_tail="$SCRIPT_DIR/console-tail.mjs"
-  if [ -n "$console_session" ] && [ -f "$console_tail" ] && tmux has-session -t "$console_session" 2>/dev/null; then
+  if command -v tmux_viewer_open >/dev/null 2>&1 && [ -f "$console_tail" ]; then
     console_runtime="$TARGET/$( (cd "$TARGET" && recipe_runtime_dir) 2>/dev/null || echo temp/recipe/runtime)"
     mkdir -p "$console_runtime"
     console_log="$console_runtime/extension-console.log"
     : > "$console_log"
-    console_window="console-${CDP_PORT}"
-    tmux kill-window -t "${console_session}:${console_window}" >/dev/null 2>&1 || true
-    tmux new-window -d -t "$console_session" -n "$console_window" \
+    tmux_viewer_open "console" "$CDP_PORT" "$console_log" "$console_runtime" "$console_runtime/console.tmux" \
       "exec node $(printf '%q' "$console_tail") --cdp-port ${CDP_PORT} --log $(printf '%q' "$console_log")"
-    echo "[recipe-harness] extension console viewer in tmux window ${console_session}:${console_window}"
   fi
 fi
 

package/adapters/extension/sidepanel-toggle.sh

@@ -19,7 +19,7 @@
 #   bash sidepanel-toggle.sh open   --cdp-port 6663 [--ext-id <extension id>]
 #   bash sidepanel-toggle.sh close  --cdp-port 6663
 #   bash sidepanel-toggle.sh toggle --cdp-port 6663
-#   bash sidepanel-toggle.sh cycle  --cdp-port 6663 [--settle-ms 4000]
+#   bash sidepanel-toggle.sh cycle  --cdp-port 6663 [--settle-ms 10000]
 #
 # CDP can inspect, activate, and close sidepanel targets. Opening the side panel
 # is done from a clicked extension-page button so Chrome treats
@@ -66,7 +66,7 @@ RUNTIME_DIST_DIR="${RECIPE_RUNTIME_DIST_DIR:-runtime-dist}"
 
 CDP_PORT="${CDP_PORT:-}"
 EXT_ID="${EXT_ID:-}"
-SETTLE_MS="${SETTLE_MS:-4000}"
+SETTLE_MS="${SETTLE_MS:-10000}"
 AGENT_DIR="${AGENT_DIR:-$SCRIPT_DIR}"
 
 while [[ $# -gt 0 ]]; do
@@ -355,7 +355,7 @@ NODE
     return 0
   fi
 
-  echo "FAIL: sidepanel did not appear within ${SETTLE_MS}ms" >&2
+  echo "FAIL: sidepanel target did not appear within ${SETTLE_MS}ms after Chrome accepted the open request" >&2
   echo "      Current CDP targets:" >&2
   print_targets >&2
   exit 3

package/adapters/extension/start-watch.sh

@@ -237,22 +237,14 @@ printf '%s\n' "$started_pid" > "$watch_pid_file"
 # The orchestrator names the session; the harness only populates windows. Resolve
 # via the run-owned ladder (RECIPE_TMUX_SESSION → agentic-runtime.json session →
 # current tmux client) — no slot-number derivation.
-tmux_session=""
-for _tv_src in "$SCRIPT_DIR/lib/tmux-session.sh" "$SCRIPT_DIR/../shared/tmux-session.sh"; do
+for _tv_src in "$SCRIPT_DIR/lib/tmux-viewer.sh" "$SCRIPT_DIR/../shared/tmux-viewer.sh"; do
   # shellcheck disable=SC1091
   [ -f "$_tv_src" ] && { . "$_tv_src"; break; }
 done
 unset _tv_src
-if command -v resolve_run_tmux_session >/dev/null 2>&1; then
-  tmux_session="$(resolve_run_tmux_session "$RUNTIME_DIR")"
-fi
-if [ -n "$tmux_session" ] && command -v tmux >/dev/null 2>&1 && tmux has-session -t "$tmux_session" 2>/dev/null; then
-  tmux_window="webpack-${WATCHER_PORT:-default}"
-  while tmux list-windows -t "$tmux_session" -F '#{window_name}' 2>/dev/null | grep -Fxq "$tmux_window"; do
-    tmux kill-window -t "${tmux_session}:${tmux_window}" 2>/dev/null || break
-  done
+if command -v tmux_viewer_open >/dev/null 2>&1; then
   log_q="$(printf '%q' "$watch_log")"
-  tmux new-window -d -t "$tmux_session" -n "$tmux_window" "exec tail -n +1 -F $log_q"
+  tmux_viewer_open "webpack" "${WATCHER_PORT:-default}" "$watch_log" "$RUNTIME_DIR" "$RUNTIME_DIR/webpack.tmux" "exec tail -n +1 -F $log_q"
 fi
 ln -sf "$(basename "$watch_log")" "$RUNTIME_DIR/webpack.log"
 
@@ -277,10 +269,8 @@ for i in {1..240}; do
       compiled=true
       break
     fi
-    echo '[recipe-harness] compact build watcher exited before compile marker' >&2
-    [ -n "$LIB_DIR" ] && node "$LIB_DIR/log-tui.mjs" events --log "$watch_log" --events "${RECIPE_LOG_EVENTS:-10}" >&2 || true
-    rm -f "$watch_pid_file" "$slot_watch_pid_file"
-    exit 1
+    echo '[recipe-harness] compact build watcher exited before compile marker; continuing to poll webpack log' >&2
+    watch_tail_pid=""
   fi
   if ! write_canonical_watch_pid; then
     if [ "$i" -le 10 ]; then

package/adapters/extension/stop-viewers.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+# stop-viewers.sh — close extension tmux viewers and console tail for one checkout.
+set -euo pipefail
+
+TARGET="$PWD"
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --target) TARGET="$2"; shift 2 ;;
+    -h|--help) echo "Usage: stop-viewers.sh [--target <metamask-extension>]"; exit 0 ;;
+    *) echo "stop-viewers: unknown arg: $1" >&2; exit 2 ;;
+  esac
+done
+
+TARGET="$(cd "$TARGET" && pwd)"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck disable=SC1091
+for _hp in "$SCRIPT_DIR/lib/harness-path.sh" "$SCRIPT_DIR/../shared/harness-path.sh"; do
+  [ -f "$_hp" ] && { . "$_hp"; break; }
+done
+unset _hp
+if ! command -v recipe_runtime_dir >/dev/null 2>&1; then
+  echo "stop-viewers: shared lib harness-path.sh not found; reinstall the runner." >&2
+  exit 1
+fi
+# shellcheck disable=SC1091
+for _tv_src in "$SCRIPT_DIR/lib/tmux-viewer.sh" "$SCRIPT_DIR/../shared/tmux-viewer.sh"; do
+  [ -f "$_tv_src" ] && { . "$_tv_src"; break; }
+done
+unset _tv_src
+
+runtime_dir="$TARGET/$(recipe_runtime_dir)"
+console_log="$runtime_dir/extension-console.log"
+set +e
+
+if command -v tmux_viewer_close_marker >/dev/null 2>&1; then
+  tmux_viewer_close_marker "$runtime_dir/webpack.tmux"
+  tmux_viewer_close_marker "$runtime_dir/console.tmux"
+fi
+if command -v tmux_viewer_sweep_prefix >/dev/null 2>&1; then
+  tmux_viewer_sweep_prefix "webpack" "$runtime_dir"
+  tmux_viewer_sweep_prefix "console" "$runtime_dir"
+fi
+
+ps -axo pid=,command= 2>/dev/null | while read -r pid command; do
+  [ -n "${pid:-}" ] || continue
+  case "$command" in
+    *console-tail.mjs*) ;;
+    *) continue ;;
+  esac
+  case "$command" in
+    *"--log $console_log"*|*"$console_log"*) kill "$pid" 2>/dev/null || true ;;
+  esac
+done
+
+rm -f "$runtime_dir/console.tmux" "$runtime_dir/webpack.tmux"
+exit 0

package/adapters/manifest.json

@@ -106,6 +106,14 @@
       "inputs": "--target --runtime-dir --runner-bin --summary",
       "outputs": "<runtime-dir>/recipe-harness-webpack.{pid,log}; optional summary; exit 0/1/2"
     },
+    {
+      "id": "extension/stop-viewers",
+      "entry": "adapters/extension/stop-viewers.sh",
+      "kind": "bash",
+      "purpose": "Close extension webpack/console tmux viewers and the checkout-scoped console tail.",
+      "inputs": "--target <metamask-extension>",
+      "outputs": "removes viewer markers and closes matching run-owned windows; exit 0/1/2"
+    },
     {
       "id": "extension/console-tail",
       "entry": "adapters/extension/console-tail.mjs",
@@ -306,6 +314,14 @@
       "inputs": "resolve_run_tmux_session [runtime-dir]; env RECIPE_TMUX_SESSION, RECIPE_RUNTIME_CONTEXT, TMUX",
       "outputs": "resolved session name on stdout (empty when none)"
     },
+    {
+      "id": "lib/tmux-viewer",
+      "entry": "adapters/shared/tmux-viewer.sh",
+      "kind": "lib",
+      "purpose": "Run-owned tmux log viewer helpers that open, replace, and clean prefixed viewer windows without slot-name inference.",
+      "inputs": "tmux_viewer_open/close_marker/sweep_prefix functions; env RECIPE_TMUX_SESSION, RECIPE_RUNTIME_CONTEXT, TMUX",
+      "outputs": "viewer windows and marker files; no-op when no run-owned session is available"
+    },
     {
       "id": "lib/activate-repo-node",
       "entry": "adapters/shared/activate-repo-node.sh",

package/adapters/shared/tmux-viewer.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# tmux-viewer.sh — run-owned tmux log viewer helpers.
+#
+# The orchestrator owns session names; the harness only opens windows inside a
+# session resolved by tmux-session.sh. When no run-owned session is available the
+# viewer is skipped. Runtime processes still run and write logs.
+
+_tv_shared_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck disable=SC1091
+for _tv_src in "$_tv_shared_dir/tmux-session.sh" "$_tv_shared_dir/lib/tmux-session.sh"; do
+  [ -f "$_tv_src" ] && { . "$_tv_src"; break; }
+done
+unset _tv_src _tv_shared_dir
+
+tmux_viewer_port_is_listening() {
+  local port="${1:-}"
+  case "$port" in ''|*[!0-9]*) return 1 ;; esac
+  command -v lsof >/dev/null 2>&1 || return 1
+  lsof -nP -iTCP:"$port" -sTCP:LISTEN -t >/dev/null 2>&1
+}
+
+tmux_viewer_open() {
+  local prefix="$1" port="$2" log="$3" runtime_dir="$4" marker_file="$5" command="$6"
+  command -v tmux >/dev/null 2>&1 || return 0
+  command -v resolve_run_tmux_session >/dev/null 2>&1 || return 0
+
+  local session window
+  session="$(resolve_run_tmux_session "$runtime_dir")"
+  { [ -n "$session" ] && tmux has-session -t "=$session" 2>/dev/null; } || return 0
+
+  window="${prefix}-${port:-default}"
+  tmux list-windows -t "$session" -F '#{window_name}' 2>/dev/null | while IFS= read -r _win; do
+    case "$_win" in
+      "$prefix"-*) ;;
+      *) continue ;;
+    esac
+    _port="${_win#"$prefix"-}"
+    if [ "$_win" != "$window" ] || ! tmux_viewer_port_is_listening "$_port"; then
+      tmux kill-window -t "${session}:${_win}" >/dev/null 2>&1 || true
+    fi
+  done
+
+  tmux kill-window -t "${session}:${window}" >/dev/null 2>&1 || true
+  tmux new-window -d -t "$session" -n "$window" "$command"
+  if [ -n "$marker_file" ]; then
+    mkdir -p "$(dirname "$marker_file")"
+    printf '%s:%s\n' "$session" "$window" > "$marker_file"
+  fi
+  printf '%s log viewer → tmux %s:%s\n' "$prefix" "$session" "$window" >&2
+}
+
+tmux_viewer_close_marker() {
+  local marker_file="$1"
+  command -v tmux >/dev/null 2>&1 || { rm -f "$marker_file"; return 0; }
+  if [ -f "$marker_file" ]; then
+    local target
+    target="$(cat "$marker_file" 2>/dev/null || true)"
+    [ -z "$target" ] || tmux kill-window -t "$target" >/dev/null 2>&1 || true
+  fi
+  rm -f "$marker_file"
+}
+
+tmux_viewer_sweep_prefix() {
+  local prefix="$1" runtime_dir="$2"
+  command -v tmux >/dev/null 2>&1 || return 0
+  command -v resolve_run_tmux_session >/dev/null 2>&1 || return 0
+  local session
+  session="$(resolve_run_tmux_session "$runtime_dir")"
+  { [ -n "$session" ] && tmux has-session -t "=$session" 2>/dev/null; } || return 0
+  tmux list-windows -t "$session" -F '#{window_name}' 2>/dev/null | while IFS= read -r _win; do
+    case "$_win" in
+      "$prefix"-*) tmux kill-window -t "${session}:${_win}" >/dev/null 2>&1 || true ;;
+    esac
+  done
+}

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

@@ -184,11 +184,11 @@ function distCheck(target) {
 function isExtensionDistStale(target) {
   return distCheck(path.resolve(target)).status === "stale";
 }
-async function cdpCheck(target, cdpPort) {
+async function cdpCheck(target, cdpPort, pageMode) {
   if (!cdpPort) return { status: "skipped" };
   try {
     const { checkExtensionRuntimeHealth } = await import("./runtime.js");
-    const report = await checkExtensionRuntimeHealth(target, cdpPort);
+    const report = await checkExtensionRuntimeHealth(target, cdpPort, { pageMode });
     return report.status === "PASS" ? { status: "pass" } : { status: "fail", findings: report.findings };
   } catch (error) {
     return { status: "fail", findings: [error instanceof Error ? error.message : String(error)] };
@@ -206,7 +206,7 @@ async function decideExtensionReadiness(target, options = {}) {
   const webpackCache = webpackCacheCheck(resolved);
   const buildLog = buildLogCheck(resolved, options.watchLog);
   const dist = distCheck(resolved);
-  const cdp = await cdpCheck(resolved, options.cdpPort);
+  const cdp = await cdpCheck(resolved, options.cdpPort, options.pageMode);
   const checks = { deps, webpackCache, buildLog, dist, cdp };
   const install = [{ id: "yarn-install", argv: ["yarn", "install", "--immutable"], cwd: resolved }];
   const relaunch = [{ id: "relaunch-browser" }];

package/dist/adapters/extension/surface.js

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 import path from "node:path";
-import { recipeRuntimePath } from "../../paths.js";
+import { recipeRuntimePath, runnerDir } from "../../paths.js";
 import { resolveExtensionSlotPorts, stopExtensionWatcher } from "../slot-ports.js";
 import { decideExtensionReadiness } from "./runtime-decision.js";
 function watcherStatus(buildLog) {
@@ -16,7 +16,7 @@ const extensionSurface = {
   },
   async runtimeStatus(target) {
     const cdpPort = process.env.CDP_PORT ? parseInt(process.env.CDP_PORT, 10) : void 0;
-    const report = await decideExtensionReadiness(target, { cdpPort });
+    const report = await decideExtensionReadiness(target, { cdpPort, pageMode: "home-or-sidepanel" });
     return {
       decision: report.decision,
       reasonCode: report.reasonCode,
@@ -47,8 +47,8 @@ const extensionSurface = {
     describe: () => "webpack watcher",
     stop(target) {
       const signalled = stopExtensionWatcher(target);
-      const port = process.env.WATCHER_PORT ?? "default";
-      spawnSync("tmux", ["kill-window", "-t", `webpack-${port}`], { stdio: "ignore", timeout: 2e3 });
+      const stopViewers = path.join(runnerDir, "adapters/extension/stop-viewers.sh");
+      spawnSync("bash", [stopViewers, "--target", target], { stdio: "ignore", timeout: 5e3 });
       const summary = signalled > 0 ? `stopped webpack watcher (${signalled} process${signalled === 1 ? "" : "es"}) for ${target}` : `webpack watcher not running for ${target} \u2014 nothing to stop`;
       return { kind: "stopped", status: 0, summary, signalled };
     }

package/dist/commands/status.js

@@ -58,8 +58,21 @@ async function handleStatus({ options }) {
         )
       );
     } else {
+      const runtime = !fast && adapter === "extension" ? await surface.runtimeStatus(target) : void 0;
       console.log(
-        JSON.stringify({ schemaVersion: 1, command: "status", adapter, target, devices, next }, null, 2)
+        JSON.stringify(
+          {
+            schemaVersion: 1,
+            command: "status",
+            adapter,
+            target,
+            devices,
+            ...runtime ? { runtime } : {},
+            next: runtime ? nextForRuntime(surface.hints.launch, surface.hints.relaunch, runtime) : next
+          },
+          null,
+          2
+        )
       );
     }
     return EXIT.ok;
@@ -73,11 +86,28 @@ async function handleStatus({ options }) {
     renderMobileLiveBlock(devices, liveView.liveMap, out);
     renderAndroidPortHints(liveView.androidPortHints, out);
     console.log(`${out("label", "Next:")} ${out("cmd", nextForLive(next, liveView.liveMap))}`);
+  } else if (!fast && adapter === "extension") {
+    const runtime = await surface.runtimeStatus(target);
+    renderRuntimeStatus(runtime, out);
+    console.log(`${out("label", "Next:")} ${out("cmd", nextForRuntime(surface.hints.launch, surface.hints.relaunch, runtime))}`);
   } else {
     console.log(`${out("label", "Next:")} ${out("cmd", next)}`);
   }
   return EXIT.ok;
 }
+function renderRuntimeStatus(runtime, out) {
+  const decisionStyle = runtime.decision === "ready" ? "ok" : runtime.decision === "blocked" ? "err" : "warn";
+  const deps = runtime.deps ? ` deps=${out(runtime.deps === "current" ? "ok" : "warn", runtime.deps)}` : "";
+  const devServer = runtime.devServer ? ` ${runtime.devServer.label}=${out(runtime.devServer.status === "up" ? "ok" : "warn", runtime.devServer.status)}` : "";
+  console.log(
+    `${out("label", "runtime:")} decision=${out(decisionStyle, runtime.decision)}${runtime.reasonCode ? ` ${out("dim", `(${runtime.reasonCode})`)}` : ""}${deps}${devServer}`
+  );
+}
+function nextForRuntime(launchHint, relaunchHint, runtime) {
+  if (runtime.decision === "ready") return "mm-harness logs";
+  if (runtime.decision === "relaunch") return launchHint;
+  return relaunchHint;
+}
 export {
   handleStatus
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"