@deeeed/metamask-harness 0.6.2 → 0.7.0

package/adapters/shared/activate-repo-ruby.sh

@@ -0,0 +1,124 @@
+# activate-repo-ruby.sh — pin the target repo's declared Ruby for non-interactive spawns
+#
+# iOS pod/gem work (yarn setup, native build) reads Ruby from PATH. Under tmux /
+# nohup / a cold checkout the PATH is the system Ruby, which does not match the
+# repo's .ruby-version and fails `bundle install` / `pod install` with native gem
+# build errors. Sourced by the leaves that trigger pods so they run the pinned
+# Ruby, mirroring activate-repo-node.sh for Node.
+#
+# On success sets REPO_RUBY_VERSION / REPO_RUBY_BIN / REPO_RUBY_BIN_DIR /
+# REPO_RUBY_PATH_PREFIX and prepends the bin dir to PATH.
+#
+# Usage:
+#   . /path/to/activate-repo-ruby.sh
+#   activate_repo_ruby [target-dir]          # 0 pinned; 1 none declared; 2 declared but unresolved
+#   activate_repo_ruby_best_effort [dir]     # never fails the caller; warns + teaches on 2
+
+_repo_ruby_matches_req() {
+  local req="$1" actual="${2:-}"
+  [ -n "$actual" ] || actual="$("$REPO_RUBY_BIN" -e 'print RUBY_VERSION' 2>/dev/null || true)"
+  [ -n "$actual" ] || return 1
+  [ "$actual" = "$req" ] && return 0
+  case "$req" in
+    *.*.*) return 1 ;;
+    *.*) [[ "$actual" == "$req."* ]] ;;
+    *) [[ "$actual" == "$req"* ]] ;;
+  esac
+}
+
+_repo_ruby_set_from_bin() {
+  local candidate="$1"
+  [ -n "$candidate" ] && [ -x "$candidate" ] || return 1
+  REPO_RUBY_BIN="$candidate"
+  REPO_RUBY_BIN_DIR="$(cd "$(dirname "$REPO_RUBY_BIN")" && pwd)"
+  REPO_RUBY_PATH_PREFIX="${REPO_RUBY_BIN_DIR}:"
+  export PATH="${REPO_RUBY_BIN_DIR}:${PATH}"
+  return 0
+}
+
+_repo_ruby_try_req() {
+  local target="$1" req="$2"
+  [ -n "$req" ] || return 1
+  REPO_RUBY_VERSION="$req"
+
+  if command -v asdf >/dev/null 2>&1; then
+    local asdf_root
+    asdf_root="$(asdf where ruby "$req" 2>/dev/null || true)"
+    if [ -n "$asdf_root" ] && _repo_ruby_set_from_bin "$asdf_root/bin/ruby" && _repo_ruby_matches_req "$req"; then
+      echo "[env] ruby $("$REPO_RUBY_BIN" -e 'print RUBY_VERSION') from .ruby-version/.tool-versions via asdf ($req)" >&2
+      return 0
+    fi
+  fi
+
+  if command -v rbenv >/dev/null 2>&1; then
+    local rbenv_root
+    rbenv_root="$(rbenv root 2>/dev/null || true)"
+    if [ -n "$rbenv_root" ] && _repo_ruby_set_from_bin "$rbenv_root/versions/$req/bin/ruby" && _repo_ruby_matches_req "$req"; then
+      echo "[env] ruby $("$REPO_RUBY_BIN" -e 'print RUBY_VERSION') from .ruby-version via rbenv ($req)" >&2
+      return 0
+    fi
+  fi
+
+  if command -v mise >/dev/null 2>&1; then
+    local mise_bin
+    mise_bin="$(mise x -C "$target" -- which ruby 2>/dev/null || true)"
+    if _repo_ruby_set_from_bin "$mise_bin" && _repo_ruby_matches_req "$req"; then
+      echo "[env] ruby $("$REPO_RUBY_BIN" -e 'print RUBY_VERSION') from .ruby-version via mise ($req)" >&2
+      return 0
+    fi
+  fi
+  return 1
+}
+
+activate_repo_ruby() {
+  local target="${1:-.}"
+  REPO_RUBY_VERSION=""
+  REPO_RUBY_BIN=""
+  REPO_RUBY_BIN_DIR=""
+  REPO_RUBY_PATH_PREFIX=""
+
+  local declared=false req=""
+  if [ -f "$target/.ruby-version" ]; then
+    declared=true
+    req="$(tr -d ' \t\r\n' < "$target/.ruby-version")"
+    req="${req#ruby-}"
+    _repo_ruby_try_req "$target" "$req" && return 0
+  fi
+  if [ -z "$req" ] && [ -f "$target/.tool-versions" ]; then
+    declared=true
+    req="$(awk '/^ruby / {print $2; exit}' "$target/.tool-versions")"
+    _repo_ruby_try_req "$target" "$req" && return 0
+  fi
+
+  if [ "$declared" != true ]; then
+    return 1
+  fi
+
+  # Declared already-on-PATH match (e.g. chruby/system already correct).
+  local path_ruby
+  path_ruby="$(command -v ruby 2>/dev/null || true)"
+  if [ -n "$req" ] && _repo_ruby_set_from_bin "$path_ruby" && _repo_ruby_matches_req "$req"; then
+    echo "[env] ruby $("$REPO_RUBY_BIN" -e 'print RUBY_VERSION') already on PATH ($req)" >&2
+    return 0
+  fi
+
+  REPO_RUBY_BIN=""
+  REPO_RUBY_BIN_DIR=""
+  REPO_RUBY_PATH_PREFIX=""
+  return 2
+}
+
+# Best-effort: never fails the caller. On a declared-but-unresolved Ruby, warn with
+# a teaching hint so a subsequent pod/gem failure is diagnosable (system Ruby).
+activate_repo_ruby_best_effort() {
+  local target="${1:-.}"
+  # Guard the call so a non-zero return (no version / unresolved) never trips the
+  # caller's set -e before we can inspect the code.
+  local rc=0
+  activate_repo_ruby "$target" || rc=$?
+  if [ "$rc" -eq 2 ]; then
+    echo "[env] repo pins ruby ${REPO_RUBY_VERSION:-?} (.ruby-version/.tool-versions) but no installed manager provided it; using system ruby." >&2
+    echo "  Next: install it — asdf install ruby ${REPO_RUBY_VERSION:-<version>}  (or rbenv install) — then re-run, so iOS gems build against the pinned Ruby" >&2
+  fi
+  return 0
+}

package/adapters/shared/open-log-window.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# open-log-window.sh — (re)open a read-only tmux tail window for a dev-server log
+# in the run-owned session, WITHOUT touching the dev-server process. Idempotent:
+# an existing same-name window is replaced with a fresh tail. Used by
+# `mm-harness logs --window` to recover a window that was closed while Metro/webpack
+# keeps running.
+#
+# Args: --window <name> --log <path> [--runtime-dir <dir>]
+# Exit: 0 opened; 1 no run-owned session / no tmux / log missing (teaches); 2 bad args.
+set -euo pipefail
+
+WINDOW=""
+LOG=""
+RUNTIME_DIR=""
+require_value() { [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; }
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --window) require_value "$@"; WINDOW="$2"; shift 2 ;;
+    --log) require_value "$@"; LOG="$2"; shift 2 ;;
+    --runtime-dir) require_value "$@"; RUNTIME_DIR="$2"; shift 2 ;;
+    -h|--help) echo "Usage: open-log-window.sh --window <name> --log <path> [--runtime-dir <dir>]"; exit 0 ;;
+    *) echo "Unknown arg: $1" >&2; exit 2 ;;
+  esac
+done
+[ -n "$WINDOW" ] && [ -n "$LOG" ] || { echo "open-log-window: --window and --log are required" >&2; exit 2; }
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck disable=SC1091
+for _src in "$SCRIPT_DIR/tmux-session.sh" "$SCRIPT_DIR/lib/tmux-session.sh"; do
+  [ -f "$_src" ] && { . "$_src"; break; }
+done
+unset _src
+
+if ! command -v tmux >/dev/null 2>&1; then
+  echo "open-log-window: tmux is not installed; cannot open a log window." >&2
+  echo "  Next: tail the log directly — mm-harness logs --full" >&2
+  exit 1
+fi
+if [ ! -f "$LOG" ]; then
+  echo "open-log-window: no log at $LOG (dev server not started for this checkout)." >&2
+  echo "  Next: start it — mm-harness launch" >&2
+  exit 1
+fi
+session=""
+command -v resolve_run_tmux_session >/dev/null 2>&1 && session="$(resolve_run_tmux_session "$RUNTIME_DIR")"
+if [ -z "$session" ] || ! tmux has-session -t "=$session" 2>/dev/null; then
+  echo "open-log-window: no run-owned tmux session to place the window in." >&2
+  echo "  Next: run inside your slot's tmux session, or set RECIPE_TMUX_SESSION=<session>, then retry" >&2
+  exit 1
+fi
+
+tmux kill-window -t "${session}:${WINDOW}" 2>/dev/null || true
+log_q="$(printf '%q' "$LOG")"
+tmux new-window -d -t "$session" -n "$WINDOW" "exec tail -n +1 -F $log_q"
+echo "log window → tmux ${session}:${WINDOW}" >&2

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

@@ -1,205 +1,3 @@
-// Farmslot pool + slot-suffix port resolution — pure JS for runner and overlay leaves.
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const coreDir = path.dirname(fileURLToPath(import.meta.url));
-
-function pathDefault(key) {
-  for (const candidate of [
-    path.join(coreDir, 'path-defaults.json'),
-    path.join(coreDir, '../../adapters/shared/path-defaults.json'),
-  ]) {
-    if (!fs.existsSync(candidate)) continue;
-    const value = JSON.parse(fs.readFileSync(candidate, 'utf8'))[key];
-    if (value) return value;
-  }
-  throw new Error(`Missing path default: ${key}`);
-}
-
-function recipeRuntimeDir() {
-  return process.env.RECIPE_RUNTIME_DIR || pathDefault('recipeRuntimeDir');
-}
-
-export function formatKvLines(kv) {
-  const lines = [];
-  if (kv.CDP_PORT !== undefined) lines.push(`CDP_PORT=${kv.CDP_PORT}`);
-  if (kv.WATCHER_PORT !== undefined) lines.push(`WATCHER_PORT=${kv.WATCHER_PORT}`);
-  if (kv.SLOT_ID) lines.push(`SLOT_ID=${kv.SLOT_ID}`);
-  if (kv.IOS_SIMULATOR) lines.push(`IOS_SIMULATOR=${kv.IOS_SIMULATOR}`);
-  return lines.length ? `${lines.join('\n')}\n` : '';
-}
-
-export function realRepoPath(repo) {
-  if (!repo) return null;
-  try {
-    return fs.realpathSync(repo);
-  } catch {
-    return null;
-  }
-}
-
-export function inferSlotSuffix(repo) {
-  const base = path.basename(repo);
-  const m = /-(\d+)$/u.exec(base);
-  return m ? m[1] : null;
-}
-
-function scoreSlot(slot, slotSuffix) {
-  const resources = slot.resources ?? {};
-  const cdp = resources.browser?.cdp_port;
-  const port = resources['dev-server']?.port;
-  const simulator = resources['ios-sim']?.simulator;
-  const session = slot.session ?? '';
-  const slotId = slot.id ?? '';
-  let score = 0;
-  if (cdp !== undefined) score += 100;
-  if (port !== undefined) score += 10;
-  if (slotSuffix) {
-    if (session === `mme-${slotSuffix}`) score += 50;
-    if (slotId.endsWith(`mme-${slotSuffix}`) || slotId.includes(`-mme-${slotSuffix}`)) score += 40;
-  }
-  if (!slotId.toLowerCase().includes('demo')) score += 5;
-  return [score, cdp, port, slotId, simulator];
-}
-
-export function resolveFarmslotPortsByRepo(repo) {
-  const realRepo = realRepoPath(repo);
-  if (!realRepo) return null;
-
-  const slotSuffix = inferSlotSuffix(realRepo);
-  const roots = [];
-  // A slot checkout lives at <workspace>/repos/<slot>; that workspace's own
-  // pool is the authoritative one for this repo — machine-global fallbacks
-  // (env root, dev checkout) apply only when the repo is not workspace-shaped.
-  if (path.basename(path.dirname(realRepo)) === 'repos') {
-    roots.push(path.join(path.dirname(path.dirname(realRepo)), 'farmslot'));
-  }
-  if (process.env.FARMSLOT_ROOT) roots.push(process.env.FARMSLOT_ROOT);
-  roots.push(path.join(os.homedir(), 'dev', 'farmslot'));
-
-  for (const root of roots) {
-    if (!root || !fs.existsSync(path.join(root, 'pool'))) continue;
-    const poolDir = path.join(root, 'pool');
-    let best = null;
-
-    for (const name of fs.readdirSync(poolDir).sort()) {
-      if (!name.endsWith('.json') || name.includes('.bak.')) continue;
-      let data;
-      try {
-        data = JSON.parse(fs.readFileSync(path.join(poolDir, name), 'utf8'));
-      } catch {
-        continue;
-      }
-      for (const slot of data.slots ?? []) {
-        const slotRepo = slot.repo ?? '';
-        if (!slotRepo) continue;
-        let slotReal;
-        try {
-          slotReal = fs.realpathSync(slotRepo);
-        } catch {
-          continue;
-        }
-        if (slotReal !== realRepo) continue;
-        const scored = scoreSlot(slot, slotSuffix);
-        if (!best || scored[0] > best[0]) best = scored;
-      }
-    }
-
-    if (best) {
-      const [, cdp, port, slotId, simulator] = best;
-      return formatKvLines({
-        ...(cdp !== undefined ? { CDP_PORT: cdp } : {}),
-        ...(port !== undefined ? { WATCHER_PORT: port } : {}),
-        ...(slotId ? { SLOT_ID: slotId } : {}),
-        ...(simulator ? { IOS_SIMULATOR: simulator } : {}),
-      });
-    }
-  }
-  return null;
-}
-
-export function resolveDefaultExtensionPorts(repo) {
-  const n = inferSlotSuffix(repo);
-  if (!n) return null;
-  return formatKvLines({
-    CDP_PORT: 6660 + Number(n),
-    WATCHER_PORT: 9010 + Number(n),
-    SLOT_ID: `local-extension-${n}`,
-  });
-}
-
-export function resolveExtensionRuntimePorts(repo) {
-  return resolveFarmslotPortsByRepo(repo) ?? resolveDefaultExtensionPorts(repo) ?? '';
-}
-
-export function resolveMobileSlotDefaults(repo) {
-  const n = inferSlotSuffix(repo);
-  if (!n) return null;
-  return formatKvLines({
-    WATCHER_PORT: 8060 + Number(n),
-    IOS_SIMULATOR: `mm-${n}`,
-    SLOT_ID: `local-mobile-${n}`,
-  });
-}
-
-export function resolveMobileRuntimeContext(repo) {
-  const ctxPath = path.join(repo, recipeRuntimeDir(), 'agentic-runtime.json');
-  if (fs.existsSync(ctxPath)) {
-    try {
-      const c = JSON.parse(fs.readFileSync(ctxPath, 'utf8'));
-      if (c.simulator || (c.metroPort != null && c.metroPort !== '')) {
-        return formatKvLines({
-          ...(c.metroPort != null && c.metroPort !== '' ? { WATCHER_PORT: c.metroPort } : {}),
-          ...(c.simulator ? { IOS_SIMULATOR: c.simulator } : {}),
-          ...(c.slotId ? { SLOT_ID: c.slotId } : {}),
-        });
-      }
-    } catch {
-      /* unreadable context falls through to the provision baseline */
-    }
-  }
-  return resolveMobileProvisionBaseline(repo);
-}
-
-// A provisioned-but-unprepared slot has no agentic-runtime.json yet, but the
-// provision baseline records the same authoritative simulator/port identity —
-// without it, a fresh slot's first launch degrades to the simctl `booted`
-// alias and misses the installed dev client entirely.
-function resolveMobileProvisionBaseline(repo) {
-  const basePath = path.join(repo, recipeRuntimeDir(), 'runway-provision.json');
-  if (!fs.existsSync(basePath)) return null;
-  try {
-    const c = JSON.parse(fs.readFileSync(basePath, 'utf8'));
-    const simulator = c.simulator?.name || c.simulator?.udid;
-    const watcherPort = c.watcherPort != null && c.watcherPort !== '' ? c.watcherPort : undefined;
-    if (!simulator && watcherPort === undefined) return null;
-    return formatKvLines({
-      ...(watcherPort !== undefined ? { WATCHER_PORT: watcherPort } : {}),
-      ...(simulator ? { IOS_SIMULATOR: simulator } : {}),
-      ...(c.slotId ? { SLOT_ID: c.slotId } : {}),
-    });
-  } catch {
-    return null;
-  }
-}
-
-export function resolveMobileRuntimePorts(repo) {
-  return (
-    resolveMobileRuntimeContext(repo)
-    ?? resolveFarmslotPortsByRepo(repo)
-    ?? resolveMobileSlotDefaults(repo)
-    ?? ''
-  );
-}
-
-export const cliFns = {
-  resolve_farmslot_ports_by_repo: resolveFarmslotPortsByRepo,
-  resolve_default_extension_ports: resolveDefaultExtensionPorts,
-  resolve_extension_runtime_ports: (repo) => resolveExtensionRuntimePorts(repo) || null,
-  resolve_mobile_runtime_context: resolveMobileRuntimeContext,
-  resolve_mobile_slot_defaults: resolveMobileSlotDefaults,
-  resolve_mobile_runtime_ports: (repo) => resolveMobileRuntimePorts(repo) || null,
-};
+// 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

@@ -1,20 +1,5 @@
 #!/usr/bin/env node
-// Node leaf for port resolution — self-contained for runner and injected overlay copies.
-
-import { cliFns } from './resolve-farmslot-ports-core.mjs';
-
-const [, , fn, repo] = process.argv;
-if (!fn || fn === '-h' || fn === '--help') {
-  process.stderr.write('Usage: resolve-farmslot-ports.mjs <fn> <repo>\n');
-  process.exit(fn ? 0 : 2);
-}
-
-const handler = cliFns[fn];
-if (!handler) {
-  process.stderr.write(`resolve-farmslot-ports: unknown fn: ${fn}\n`);
-  process.exit(2);
-}
-
-const out = handler(repo ?? '.');
-if (!out?.trim()) process.exit(1);
-process.stdout.write(out.endsWith('\n') ? out : `${out}\n`);
+// 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

@@ -1,105 +1,7 @@
 #!/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).
-#
-# Usage:
-#   . resolve-farmslot-ports.sh
-#   resolve_extension_runtime_ports /path/to/metamask-extension-N
-#     -> prints CDP_PORT=... WATCHER_PORT=... SLOT_ID=... lines
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-_RESOLVE_PORTS_MJS="$SCRIPT_DIR/resolve-farmslot-ports.mjs"
-
-_resolve_ports_cli() {
-  node "$_RESOLVE_PORTS_MJS" "$1" "${2:-.}"
-}
-
-resolve_farmslot_ports_by_repo() {
-  _resolve_ports_cli resolve_farmslot_ports_by_repo "$1"
-}
-
-infer_extension_slot_suffix() {
-  local repo="$1" base
-  base="$(basename "$repo")"
-  if [[ "$base" =~ -([0-9]+)$ ]]; then
-    printf '%s' "${BASH_REMATCH[1]}"
-    return 0
-  fi
-  return 1
-}
-
-resolve_default_extension_ports() {
-  _resolve_ports_cli resolve_default_extension_ports "$1"
-}
-
-resolve_extension_runtime_ports() {
-  _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_ports_cli resolve_farmslot_ports_by_repo "$repo" 2>/dev/null)"; then
-    from_pool=true
-  elif resolved="$(_resolve_ports_cli resolve_default_extension_ports "$repo" 2>/dev/null)"; then
-    from_pool=false
-  else
-    return 0
-  fi
-  while IFS= read -r line; do
-    [ -n "$line" ] || continue
-    key="${line%%=*}"
-    val="${line#*=}"
-    case "$key" in
-      CDP_PORT)
-        if [ "$from_pool" = true ] || [ -z "${CDP_PORT:-}" ]; then CDP_PORT="$val"; fi
-        ;;
-      WATCHER_PORT)
-        if [ "$from_pool" = true ] || [ -z "${WATCHER_PORT:-}" ]; then WATCHER_PORT="$val"; fi
-        ;;
-      SLOT_ID)
-        if [ "$from_pool" = true ] || [ -z "${RECIPE_SLOT_ID:-}" ]; then RECIPE_SLOT_ID="$val"; fi
-        ;;
-    esac
-  done <<< "$resolved"
-}
-
-resolve_mobile_slot_defaults() {
-  _resolve_ports_cli resolve_mobile_slot_defaults "$1"
-}
-
-resolve_mobile_runtime_context() {
-  _resolve_ports_cli resolve_mobile_runtime_context "$1"
-}
-
-resolve_mobile_runtime_ports() {
-  _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_ports_cli resolve_farmslot_ports_by_repo "$repo" 2>/dev/null)"; then
-    from_pool=true
-  elif resolved="$(_resolve_ports_cli resolve_mobile_slot_defaults "$repo" 2>/dev/null)"; then
-    from_pool=false
-  else
-    return 0
-  fi
-  while IFS= read -r line; do
-    [ -n "$line" ] || continue
-    key="${line%%=*}"
-    val="${line#*=}"
-    case "$key" in
-      WATCHER_PORT)
-        if [ "$from_pool" = true ] || [ -z "${WATCHER_PORT:-}" ]; then WATCHER_PORT="$val"; fi
-        ;;
-      IOS_SIMULATOR)
-        if [ "$from_pool" = true ] || [ -z "${IOS_SIMULATOR:-}" ]; then IOS_SIMULATOR="$val"; fi
-        ;;
-      SLOT_ID)
-        if [ "$from_pool" = true ] || [ -z "${RECIPE_SLOT_ID:-}" ]; then RECIPE_SLOT_ID="$val"; fi
-        ;;
-    esac
-  done <<< "$resolved"
-}
+# 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"