@deeeed/metamask-harness 0.4.0 → 0.5.1

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

@@ -1,4 +1,5 @@
-# resolve-farmslot-ports.sh — resolve CDP + watcher ports for an extension checkout
+#!/usr/bin/env bash
+# resolve-farmslot-ports.sh — bash-compat wrapper over resolve-farmslot-ports.mjs
 #
 # Farmslot pool JSON is authoritative when a slot repo matches; otherwise fall back
 # to the local-extension-N formula (6660+N / 9010+N).
@@ -8,85 +9,15 @@
 #   resolve_extension_runtime_ports /path/to/metamask-extension-N
 #     -> prints CDP_PORT=... WATCHER_PORT=... SLOT_ID=... lines
 
-resolve_farmslot_ports_by_repo() {
-  local repo="$1"
-  local farmslot_root="${FARMSLOT_ROOT:-}"
-  [ -n "$repo" ] || return 1
-  repo="$(cd "$repo" && pwd -P)"
-
-  local root candidate match
-  for root in "$farmslot_root" "$HOME/dev/farmslot"; do
-    [ -n "$root" ] && [ -d "$root/pool" ] || continue
-    match="$(POOL_ROOT="$root" REPO_TARGET="$repo" python3 - <<'PY'
-import glob, json, os, re, sys
-
-pool_root = os.environ["POOL_ROOT"]
-repo = os.path.realpath(os.environ["REPO_TARGET"])
-base = os.path.basename(repo)
-slot_suffix = None
-m = re.search(r"-(\d+)$", base)
-if m:
-    slot_suffix = m.group(1)
-
-def score_slot(slot):
-    resources = slot.get("resources") or {}
-    cdp = (resources.get("browser") or {}).get("cdp_port")
-    port = (resources.get("dev-server") or {}).get("port")
-    session = slot.get("session") or ""
-    slot_id = slot.get("id") or ""
-    score = 0
-    if cdp is not None:
-        score += 100
-    if port is not None:
-        score += 10
-    if slot_suffix:
-        if session == f"mme-{slot_suffix}":
-            score += 50
-        if slot_id.endswith(f"mme-{slot_suffix}") or f"-mme-{slot_suffix}" in slot_id:
-            score += 40
-    if "demo" not in slot_id.lower():
-        score += 5
-    return score, cdp, port, slot_id
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+_RESOLVE_PORTS_MJS="$SCRIPT_DIR/resolve-farmslot-ports.mjs"
 
-best = None
-for path in sorted(glob.glob(os.path.join(pool_root, "pool", "*.json"))):
-    if ".bak." in os.path.basename(path):
-        continue
-    try:
-        data = json.load(open(path, encoding="utf-8"))
-    except Exception:
-        continue
-    for slot in data.get("slots") or []:
-        slot_repo = slot.get("repo") or ""
-        if not slot_repo:
-            continue
-        try:
-            if os.path.realpath(slot_repo) != repo:
-                continue
-        except Exception:
-            continue
-        scored = score_slot(slot)
-        if best is None or scored[0] > best[0]:
-            best = scored
-
-if best is None:
-    sys.exit(1)
+_resolve_ports_cli() {
+  node "$_RESOLVE_PORTS_MJS" "$1" "${2:-.}"
+}
 
-_, cdp, port, slot_id = best
-if cdp is not None:
-    print(f"CDP_PORT={cdp}")
-if port is not None:
-    print(f"WATCHER_PORT={port}")
-if slot_id:
-    print(f"SLOT_ID={slot_id}")
-sys.exit(0)
-PY
-)" || continue
-    [ -n "$match" ] || continue
-    printf '%s\n' "$match"
-    return 0
-  done
-  return 1
+resolve_farmslot_ports_by_repo() {
+  _resolve_ports_cli resolve_farmslot_ports_by_repo "$1"
 }
 
 infer_extension_slot_suffix() {
@@ -100,27 +31,18 @@ infer_extension_slot_suffix() {
 }
 
 resolve_default_extension_ports() {
-  local repo="$1" n
-  n="$(infer_extension_slot_suffix "$repo" || true)"
-  [ -n "$n" ] || return 1
-  printf 'CDP_PORT=%s\n' "$((6660 + n))"
-  printf 'WATCHER_PORT=%s\n' "$((9010 + n))"
-  printf 'SLOT_ID=local-extension-%s\n' "$n"
+  _resolve_ports_cli resolve_default_extension_ports "$1"
 }
 
 resolve_extension_runtime_ports() {
-  local repo="${1:-.}"
-  if resolve_farmslot_ports_by_repo "$repo"; then
-    return 0
-  fi
-  resolve_default_extension_ports "$repo"
+  _resolve_ports_cli resolve_extension_runtime_ports "${1:-.}"
 }
 
 apply_resolved_extension_ports() {
   local repo="${1:-.}" line key val from_pool=false resolved=""
-  if resolved="$(resolve_farmslot_ports_by_repo "$repo" 2>/dev/null)"; then
+  if resolved="$(_resolve_ports_cli resolve_farmslot_ports_by_repo "$repo" 2>/dev/null)"; then
     from_pool=true
-  elif resolved="$(resolve_default_extension_ports "$repo" 2>/dev/null)"; then
+  elif resolved="$(_resolve_ports_cli resolve_default_extension_ports "$repo" 2>/dev/null)"; then
     from_pool=false
   else
     return 0
@@ -143,52 +65,23 @@ apply_resolved_extension_ports() {
   done <<< "$resolved"
 }
 
-# Mobile slot defaults: derive Metro port + iOS simulator name from directory suffix.
-# Port formula: 8060 + N (slot 1 → 8061). iOS simulator: mm-N.
-# Mirrors the extension convention (6660+N / 9010+N) for multi-slot mobile farms.
 resolve_mobile_slot_defaults() {
-  local repo="$1" n
-  n="$(infer_extension_slot_suffix "$repo" || true)"
-  [ -n "$n" ] || return 1
-  printf 'WATCHER_PORT=%s\n' "$((8060 + n))"
-  printf 'IOS_SIMULATOR=mm-%s\n' "$n"
-  printf 'SLOT_ID=local-mobile-%s\n' "$n"
+  _resolve_ports_cli resolve_mobile_slot_defaults "$1"
 }
 
-# Slot context the orchestrator's prepare wrote INTO the checkout — the
-# authoritative device/port mapping for this repo (survives pool renames that
-# break any naming formula). Highest-priority detection source.
 resolve_mobile_runtime_context() {
-  local repo="$1" ctx
-  ctx="$repo/${RECIPE_RUNTIME_DIR:-temp/recipe/runtime}/agentic-runtime.json"
-  [ -f "$ctx" ] || return 1
-  node -e '
-    try {
-      const c = JSON.parse(require("fs").readFileSync(process.argv[1], "utf8"));
-      if (!c.simulator && !c.metroPort) process.exit(1);
-      if (c.metroPort) console.log(`WATCHER_PORT=${c.metroPort}`);
-      if (c.simulator) console.log(`IOS_SIMULATOR=${c.simulator}`);
-      if (c.slotId) console.log(`SLOT_ID=${c.slotId}`);
-    } catch { process.exit(1); }
-  ' "$ctx" 2>/dev/null
+  _resolve_ports_cli resolve_mobile_runtime_context "$1"
 }
 
 resolve_mobile_runtime_ports() {
-  local repo="${1:-.}"
-  if resolve_mobile_runtime_context "$repo"; then
-    return 0
-  fi
-  if resolve_farmslot_ports_by_repo "$repo"; then
-    return 0
-  fi
-  resolve_mobile_slot_defaults "$repo"
+  _resolve_ports_cli resolve_mobile_runtime_ports "${1:-.}"
 }
 
 apply_resolved_mobile_ports() {
   local repo="${1:-.}" line key val from_pool=false resolved=""
-  if resolved="$(resolve_farmslot_ports_by_repo "$repo" 2>/dev/null)"; then
+  if resolved="$(_resolve_ports_cli resolve_farmslot_ports_by_repo "$repo" 2>/dev/null)"; then
     from_pool=true
-  elif resolved="$(resolve_mobile_slot_defaults "$repo" 2>/dev/null)"; then
+  elif resolved="$(_resolve_ports_cli resolve_mobile_slot_defaults "$repo" 2>/dev/null)"; then
     from_pool=false
   else
     return 0
@@ -209,4 +102,4 @@ apply_resolved_mobile_ports() {
         ;;
     esac
   done <<< "$resolved"
-}
+}

package/dist/adapters/core/surface.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+import { depsCheck } from "@farmslot/recipe-harness/runtime/deps-readiness";
+const coreSurface = {
+  adapter: "core",
+  headless: true,
+  resolveSlotPorts() {
+  },
+  async runtimeStatus(target) {
+    const deps = depsCheck(path.resolve(target));
+    const ready = deps.status === "current";
+    return {
+      decision: ready ? "ready" : "install",
+      reasonCode: ready ? "deps-present" : `deps-${deps.status}`,
+      reasons: [
+        ready ? "Core is headless; dependencies are installed. Run recipes with mm-harness run." : "Core is headless; dependencies are not fully installed."
+      ],
+      deps: deps.status
+    };
+  },
+  runwayProvision: {
+    async run(target, options) {
+      return {
+        schemaVersion: 1,
+        command: "provision",
+        adapter: "core",
+        target: path.resolve(target),
+        status: "fail",
+        exitCode: 2,
+        error: { code: "UNSUPPORTED_ADAPTER", message: "core is headless and has no mobile simulator to provision.", userAction: options.rerunCommand || "mm-harness run <recipe> --adapter core" }
+      };
+    }
+  },
+  devServer: {
+    describe: () => "no dev server (headless)",
+    stop() {
+      return {
+        kind: "headless",
+        message: "core is headless \u2014 no dev server runs for a core checkout",
+        userAction: "use mm-harness verify (readiness) or mm-harness run (execute a recipe)"
+      };
+    }
+  },
+  logSources() {
+    return [];
+  },
+  hints: {
+    launch: "mm-harness run <recipe>   # run recipes against the headless core",
+    relaunch: "mm-harness verify"
+  }
+};
+export {
+  coreSurface
+};

package/dist/adapters/extension/ensure-ready.js

@@ -0,0 +1,109 @@
+import path from "node:path";
+import { resolveExtensionId } from "./extension-id.js";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function jsonList(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(5e3) });
+    if (!res.ok) return [];
+    const value = await res.json();
+    return Array.isArray(value) ? value : [];
+  } catch {
+    return [];
+  }
+}
+async function closeTab(port, id) {
+  try {
+    await fetch(`http://127.0.0.1:${port}/json/close/${id}`, { signal: AbortSignal.timeout(4e3) });
+  } catch {
+  }
+}
+async function activateTab(port, id) {
+  try {
+    await fetch(`http://127.0.0.1:${port}/json/activate/${id}`, { signal: AbortSignal.timeout(4e3) });
+  } catch {
+  }
+}
+function isStrayTab(url) {
+  if (typeof url !== "string") return false;
+  return /^chrome:\/\/newtab\/?$/.test(url) || /^chrome:\/\/new-tab-page\b/.test(url) || url === "about:blank";
+}
+async function openHome(port, extensionId) {
+  const endpoint = `http://127.0.0.1:${port}/json/new?${encodeURIComponent(`chrome-extension://${extensionId}/home.html`)}`;
+  try {
+    let res = await fetch(endpoint, { method: "PUT", signal: AbortSignal.timeout(8e3) });
+    if (res.status === 404 || res.status === 405) res = await fetch(endpoint, { signal: AbortSignal.timeout(8e3) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+function homePages(targets, extensionId) {
+  const prefix = `chrome-extension://${extensionId}`;
+  return targets.filter(
+    (t) => t.type === "page" && typeof t.url === "string" && t.url.startsWith(prefix) && t.url.includes("/home.html") && t.id
+  );
+}
+async function ensureExtensionReady(target, options) {
+  const resolved = path.resolve(target);
+  const { cdpPort } = options;
+  const base = (extra) => ({
+    schemaVersion: 1,
+    adapter: "extension",
+    target: resolved,
+    cdpPort,
+    extensionId: null,
+    opened: false,
+    homeTabs: { before: 0, closed: 0, after: 0 },
+    ready: false,
+    reasonCode: "unknown",
+    health: { status: "unknown", findings: [] },
+    ...extra
+  });
+  const { extensionId } = await resolveExtensionId(resolved, { cdpPort });
+  if (!extensionId) return base({ reasonCode: "no-extension-id" });
+  const homes = homePages(await jsonList(cdpPort), extensionId);
+  const before = homes.length;
+  let opened = false;
+  let closed = 0;
+  if (homes.length > 1) {
+    for (const h of homes) {
+      await closeTab(cdpPort, String(h.id));
+      closed += 1;
+    }
+    await sleep(500);
+    opened = await openHome(cdpPort, extensionId);
+    await sleep(1500);
+  } else if (homes.length === 0) {
+    opened = await openHome(cdpPort, extensionId);
+    await sleep(1500);
+  }
+  const converged = await jsonList(cdpPort);
+  const homesNow = homePages(converged, extensionId);
+  if (homesNow.length >= 1) {
+    for (const t of converged) {
+      if (t.type === "page" && t.id && isStrayTab(t.url)) await closeTab(cdpPort, String(t.id));
+    }
+    if (homesNow[0]?.id) await activateTab(cdpPort, String(homesNow[0].id));
+  }
+  const after = homePages(await jsonList(cdpPort), extensionId).length;
+  let health = { status: "unknown", findings: [] };
+  try {
+    const { checkExtensionRuntimeHealth } = await import("./runtime.js");
+    const report = await checkExtensionRuntimeHealth(resolved, cdpPort);
+    health = { status: report.status, findings: report.findings };
+  } catch (error) {
+    health = { status: "FAIL", findings: [error instanceof Error ? error.message : String(error)] };
+  }
+  const ready = health.status === "PASS" && after === 1;
+  return base({
+    extensionId,
+    opened,
+    homeTabs: { before, closed, after },
+    ready,
+    reasonCode: ready ? "ready" : after !== 1 ? "tab-count" : "unhealthy",
+    health
+  });
+}
+export {
+  ensureExtensionReady
+};

package/dist/adapters/extension/extension-id.js

@@ -0,0 +1,62 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+const DIST_MANIFEST = "dist/chrome/manifest.json";
+function extensionIdFromKey(keyBase64) {
+  const der = Buffer.from(keyBase64, "base64");
+  const hash = crypto.createHash("sha256").update(der).digest();
+  let id = "";
+  for (let i = 0; i < 16; i += 1) {
+    id += String.fromCharCode(97 + (hash[i] >> 4));
+    id += String.fromCharCode(97 + (hash[i] & 15));
+  }
+  return id;
+}
+function idFromDistManifest(target) {
+  const manifestPath = path.join(target, DIST_MANIFEST);
+  if (!fs.existsSync(manifestPath)) return null;
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    return typeof manifest.key === "string" && manifest.key.length > 0 ? extensionIdFromKey(manifest.key) : null;
+  } catch {
+    return null;
+  }
+}
+async function cdpExtensionIds(cdpPort) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${cdpPort}/json/list`, { signal: AbortSignal.timeout(4e3) });
+    if (!res.ok) return [];
+    const targets = await res.json();
+    const ids = /* @__PURE__ */ new Set();
+    for (const t of targets) {
+      const m = /^chrome-extension:\/\/([^/]+)/u.exec(String(t.url ?? ""));
+      if (m) ids.add(m[1]);
+    }
+    return [...ids];
+  } catch {
+    return [];
+  }
+}
+async function resolveExtensionId(target, options = {}) {
+  const resolved = path.resolve(target);
+  const fromKey = idFromDistManifest(resolved);
+  let cdpIds = null;
+  if (options.cdpPort) cdpIds = await cdpExtensionIds(options.cdpPort);
+  if (fromKey) {
+    return {
+      adapter: "extension",
+      target: resolved,
+      extensionId: fromKey,
+      source: "manifest-key",
+      verified: cdpIds ? cdpIds.includes(fromKey) : null
+    };
+  }
+  if (cdpIds && cdpIds.length === 1) {
+    return { adapter: "extension", target: resolved, extensionId: cdpIds[0], source: "cdp-target", verified: true };
+  }
+  return { adapter: "extension", target: resolved, extensionId: null, source: "none", verified: cdpIds ? false : null };
+}
+export {
+  extensionIdFromKey,
+  resolveExtensionId
+};