@zerwiz/ymir 0.1.4 → 0.1.7

package/.agents/tests/assets/board-render-harness.mjs

@@ -0,0 +1,117 @@
+// Render a built bearings board's shipped inline script under a minimal DOM
+// shim and print what the renderer actually produced, so board behavior is
+// asserted through the real template rather than by reading its source.
+//
+// Usage: node board-render-harness.mjs <built-board.html>
+// Prints one JSON document: { stats:[{n,label}], charted:[{title,sub,badges,pickable}] }
+import { readFileSync } from "node:fs";
+
+const html = readFileSync(process.argv[2], "utf8");
+
+class Node {
+  constructor(tag) {
+    this.tagName = tag;
+    this.className = "";
+    this.children = [];
+    this.attributes = {};
+    this._text = "";
+    this.hidden = false;
+    this.disabled = false;
+    this.innerHTML = "";
+    this.parentNode = null;
+    this.type = "";
+    this.value = "";
+    this.checked = false;
+    this.classList = {
+      add: (c) => { this.className = (this.className + " " + c).trim(); },
+      contains: (c) => this.className.split(/\s+/).includes(c),
+    };
+  }
+  get textContent() {
+    return this.children.length
+      ? this.children.map((c) => c.textContent).join("")
+      : this._text;
+  }
+  set textContent(v) { this._text = String(v); this.children = []; }
+  appendChild(n) { n.parentNode = this; this.children.push(n); return n; }
+  setAttribute(k, v) { this.attributes[k] = v; }
+  addEventListener() {}
+  querySelectorAll(sel) {
+    const want = sel.replace(/^\./, "").replace(/:checked$/, "");
+    const checkedOnly = sel.endsWith(":checked");
+    const out = [];
+    const walk = (n) => {
+      for (const c of n.children) {
+        if (c.className.split(/\s+/).includes(want) && (!checkedOnly || c.checked)) out.push(c);
+        walk(c);
+      }
+    };
+    walk(this);
+    return out;
+  }
+}
+
+const byId = new Map();
+const dataNode = new Node("script");
+dataNode.textContent = html
+  .split('<script id="bearings-data" type="application/json">')[1]
+  .split("</script>")[0];
+byId.set("bearings-data", dataNode);
+
+globalThis.document = {
+  createElement: (tag) => new Node(tag),
+  // Lazily mint any element the page asks for: the shim tracks whatever ids
+  // the shipped template actually uses instead of pinning a fixed list.
+  getElementById: (id) => {
+    if (!byId.has(id)) {
+      const n = new Node("div");
+      new Node("div").appendChild(n);
+      byId.set(id, n);
+    }
+    return byId.get(id);
+  },
+  querySelector: (sel) => {
+    const id = "sel:" + sel;
+    if (!byId.has(id)) byId.set(id, new Node("div"));
+    return byId.get(id);
+  },
+};
+globalThis.window = {};
+globalThis.TextEncoder = TextEncoder;
+
+const script = html.slice(html.indexOf("<script>") + "<script>".length, html.lastIndexOf("</script>"));
+new Function(script)();
+
+const badgesOf = (row) =>
+  row.children
+    .filter((c) => c.className.includes("fm-badge"))
+    .map((c) => ({ tone: c.className.replace(/.*fm-badge--/, "").trim(), text: c.textContent }));
+
+const strip = byId.get("bb-stats") || new Node("div");
+const stats = strip.children.map((t) => ({
+  n: Number(t.children.find((c) => c.className.includes("bb-stat__num"))?.textContent),
+  label: t.children.find((c) => c.className.includes("bb-stat__label"))?.textContent,
+}));
+
+const ch = byId.get("bb-charted") || new Node("div");
+const charted = ch.children
+  .filter((r) => r.className.split(/\s+/).includes("bb-row"))
+  .map((row) => {
+    const main = row.children.find((c) => c.className.includes("bb-row__main"));
+    return {
+      title: main?.children.find((c) => c.className.includes("bb-row__title"))?.textContent ?? "",
+      sub: main?.children.find((c) => c.className.includes("bb-row__sub"))?.textContent ?? "",
+      badges: badgesOf(row),
+      pickable: row.children.some((c) => c.className.includes("bb-pick") && !c.className.includes("spacer")),
+    };
+  });
+// A fail-closed render replaces the page body instead of the board sections, so
+// surface it rather than reporting an empty board as a successful render.
+const errorText = [...byId.entries()]
+  .filter(([k]) => k.startsWith("sel:"))
+  .flatMap(([, n]) => n.children.map((c) => c.textContent))
+  .join(" ");
+const empty = ch.children.filter((c) => c.className.includes("bb-empty")).map((c) => c.textContent);
+const more = ch.children.filter((c) => c.className.includes("bb-morechip")).map((c) => c.textContent);
+
+process.stdout.write(JSON.stringify({ stats, charted, empty, more, error: errorText }) + "\n");

package/.agents/tests/cmux-test-safety.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# tests/cmux-test-safety.sh - shared hard guard against a real-cmux test's
+# cleanup ever touching a workspace that is not one the test itself just
+# created. Mirrors tests/herdr-test-safety.sh's/tests/zellij-test-safety.sh's
+# guard, adapted to cmux's shape: unlike herdr/zellij, cmux has no isolated,
+# throwaway SESSION a test can spin up and tear down on its own - there is
+# just "the app", the SAME real running instance the captain uses day to day.
+# So the safety rule here is not about avoiding the wrong session name; it is
+# about never closing a workspace this test did not itself create, and never
+# enumerating-and-closing.
+#
+# Fails CLOSED: any ambiguity (an empty id, a plain label without the fm-test-
+# prefix, a live workspace whose title does not match the scoped title for
+# what the test expects) refuses rather than proceeding, because the cost of a
+# false refusal (a leaked test workspace, cleaned up by hand later) is recoverable,
+# while the cost of a false negative (closing a workspace that is not the
+# test's own) is not - especially here, where that workspace could belong to
+# the captain's own live work.
+set -u
+
+# cmux_refuse_if_unsafe: 0 (SAFE to proceed) only if <workspace_id> is
+# non-empty, <want_label> carries the fm-test- prefix, and the workspace is
+# CURRENTLY LISTED with the scoped title for <want_label>. 1 (REFUSE) on
+# anything else. Requires bin/backends/cmux.sh already sourced.
+cmux_refuse_if_unsafe() {  # <workspace_id> <want_label>
+  local wsid=$1 want_label=$2 want_title title
+  [ -n "$wsid" ] || { echo "cmux safety guard: refusing - empty workspace id" >&2; return 1; }
+  case "$want_label" in
+    fm-test-*) : ;;
+    *) echo "cmux safety guard: refusing - label '$want_label' does not carry the fm-test- prefix" >&2; return 1 ;;
+  esac
+  want_title=$(fm_backend_cmux_scoped_title "$want_label")
+  title=$(fm_backend_cmux_cli workspace list --json --id-format uuids 2>/dev/null | jq -r --arg id "$wsid" '.workspaces[]? | select(.id == $id) | .title' 2>/dev/null)
+  if [ "$title" != "$want_title" ]; then
+    echo "cmux safety guard: refusing - workspace $wsid title '${title:-<not found>}' does not match expected '$want_title'" >&2
+    return 1
+  fi
+  return 0
+}
+
+# cmux_safe_close_workspace: the ONLY sanctioned way for a test to tear down
+# a workspace it created. Guards first (cmux_refuse_if_unsafe), then closes
+# the whole workspace (never a bulk/enumerate-based close). Best-effort past
+# the guard (a workspace already gone must not fail the caller's cleanup
+# trap) - but the guard itself is NOT best-effort: a refusal here means
+# cleanup leaves the isolated, throwaway workspace for that fm-test- label open
+# rather than risk the wrong target.
+cmux_safe_close_workspace() {  # <workspace_id> <want_label>
+  cmux_refuse_if_unsafe "$1" "$2" || return 1
+  fm_backend_cmux_cli close-workspace --workspace "$1" >/dev/null 2>&1 || true
+}

package/.agents/tests/fixtures.sh

@@ -0,0 +1,291 @@
+#!/usr/bin/env bash
+# tests/fixtures.sh - shared fake-toolchain and spawn-world builders.
+#
+# Source this from a test file:
+#   # shellcheck source=tests/fixtures.sh
+#   . "$(dirname "${BASH_SOURCE[0]}")/fixtures.sh"
+#
+# Generic reporters, temp roots, git fixtures, and fail/pass/fm_test_cleanup
+# come from tests/lib.sh, pulled in below. This file owns the shared fake
+# no-mistakes, gh, gh-axi, tmux, ssh, and spawn-world helpers. Wake-queue mocks
+# stay in wake-helpers.sh; secondmate-lifecycle mocks stay in
+# secondmate-helpers.sh.
+#
+# FM_TEST_NO_MISTAKES_VERSION is the single default version for the shared fake
+# no-mistakes banner. Override a single case with FM_FAKE_NO_MISTAKES_VERSION
+# rather than editing a stub body.
+
+# shellcheck source=tests/lib.sh
+. "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
+
+if [ -n "${FM_TEST_FIXTURES_SOURCED:-}" ]; then
+  return 0
+fi
+FM_TEST_FIXTURES_SOURCED=1
+
+# Production floor lives in bin/fm-bootstrap.sh (NO_MISTAKES_MIN). Keep this
+# equal to that floor so a bump is one constant here plus that production pin.
+export FM_TEST_NO_MISTAKES_VERSION=1.46.0
+export FM_TEST_NO_MISTAKES_FAKE_VERSION="no-mistakes version v${FM_TEST_NO_MISTAKES_VERSION} (fake)"
+export FM_TEST_NO_MISTAKES_FAKE_VERSION_TS="${FM_TEST_NO_MISTAKES_FAKE_VERSION} 2026-06-27T00:02:18Z"
+export FM_TEST_GH_AXI_VERSION=0.1.29
+
+# --- fake no-mistakes -------------------------------------------------------
+
+# fm_test_fake_no_mistakes <fakebin>
+# Drops a no-mistakes stub that answers --version with
+# FM_TEST_NO_MISTAKES_FAKE_VERSION (or FM_FAKE_NO_MISTAKES_VERSION when set)
+# and exits 0 for every other invocation.
+fm_test_fake_no_mistakes() {
+  local fakebin=$1
+  cat > "$fakebin/no-mistakes" <<SH
+#!/usr/bin/env bash
+if [ "\${1:-}" = --version ]; then
+  printf '%s\\n' "\${FM_FAKE_NO_MISTAKES_VERSION:-$FM_TEST_NO_MISTAKES_FAKE_VERSION}"
+  exit 0
+fi
+exit 0
+SH
+  chmod +x "$fakebin/no-mistakes"
+}
+
+# fm_test_fake_no_mistakes_init_doctor <fakebin>
+# Secondmate-lifecycle stub: init/doctor touch marker files; other verbs exit 2.
+# Does not answer --version (those suites never probe the floor).
+fm_test_fake_no_mistakes_init_doctor() {
+  local fakebin=$1
+  cat > "$fakebin/no-mistakes" <<'SH'
+#!/usr/bin/env bash
+set -eu
+case "${1:-}" in
+  init) touch .no-mistakes-init ;;
+  doctor) touch .no-mistakes-doctor ;;
+  *) exit 2 ;;
+esac
+SH
+  chmod +x "$fakebin/no-mistakes"
+}
+
+# --- fake gh / gh-axi -------------------------------------------------------
+
+# fm_test_fake_gh <fakebin>
+# Authenticates (`gh auth status` exits 0) and otherwise exits 0.
+fm_test_fake_gh() {
+  local fakebin=$1
+  cat > "$fakebin/gh" <<'SH'
+#!/usr/bin/env bash
+if [ "${1:-}" = auth ] && [ "${2:-}" = status ]; then
+  exit 0
+fi
+exit 0
+SH
+  chmod +x "$fakebin/gh"
+}
+
+# fm_test_fake_gh_axi <fakebin>
+# Answers --version with FM_FAKE_GH_AXI_VERSION or FM_TEST_GH_AXI_VERSION.
+fm_test_fake_gh_axi() {
+  local fakebin=$1
+  fm_fake_version_tool "$fakebin" gh-axi FM_FAKE_GH_AXI_VERSION "$FM_TEST_GH_AXI_VERSION"
+}
+
+# --- fake tmux / ssh / sleep ------------------------------------------------
+
+# fm_test_fake_tmux_spawn <fakebin>
+# Spawn-world tmux: pane_current_path from FM_FAKE_PANE_PATH, session named
+# firstmate, window ops succeed, send-keys succeed. When FM_FAKE_LAUNCH_LOG is
+# set, each send-keys -l payload is appended one per line. Optional
+# FM_FAKE_DUPLICATE_WINDOW is printed from list-windows.
+#
+# The pane path defaults to empty when FM_FAKE_PANE_PATH is unset. Window
+# cleanup and option operations are no-ops. Launch logging is env-gated, so
+# suites that do not set FM_FAKE_LAUNCH_LOG keep a silent send-keys.
+fm_test_fake_tmux_spawn() {
+  local fakebin=$1
+  cat > "$fakebin/tmux" <<'SH'
+#!/usr/bin/env bash
+set -u
+case "$*" in
+  *"#{pane_current_path}"*) printf '%s\n' "${FM_FAKE_PANE_PATH:-}"; exit 0 ;;
+esac
+case "${1:-}" in
+  display-message) printf 'firstmate\n'; exit 0 ;;
+  list-windows)
+    if [ -n "${FM_FAKE_DUPLICATE_WINDOW:-}" ]; then
+      printf '%s\n' "$FM_FAKE_DUPLICATE_WINDOW"
+    fi
+    exit 0
+    ;;
+  has-session|new-session|new-window|kill-window|set-window-option) exit 0 ;;
+  send-keys)
+    if [ -n "${FM_FAKE_LAUNCH_LOG:-}" ]; then
+      prev=
+      for a in "$@"; do
+        if [ "$prev" = "-l" ]; then
+          printf '%s\n' "$a" >> "$FM_FAKE_LAUNCH_LOG"
+        fi
+        prev=$a
+      done
+    fi
+    exit 0
+    ;;
+esac
+exit 0
+SH
+  chmod +x "$fakebin/tmux"
+}
+
+# fm_test_fake_tmux_send <fakebin>
+# Send-world tmux: logs send-keys -l payloads to FM_SEND_LOG, reports a numeric
+# cursor_y, and renders an empty bordered composer so the submit path reads
+# empty. Env knobs:
+#   FM_FAKE_TMUX_SEND_FAIL=1  send-keys exits 1
+#   FM_FAKE_TMUX_COMPOSER=pending  capture-pane shows leftover composer text
+fm_test_fake_tmux_send() {
+  local fakebin=$1
+  cat > "$fakebin/tmux" <<'SH'
+#!/usr/bin/env bash
+set -u
+case "${1:-}" in
+  send-keys)
+    [ "${FM_FAKE_TMUX_SEND_FAIL:-0}" = 1 ] && exit 1
+    shift
+    literal=0
+    while [ $# -gt 0 ]; do
+      case "$1" in
+        -t) shift 2 ;;
+        -l) literal=1; shift ;;
+        *) break ;;
+      esac
+    done
+    if [ "$literal" = 1 ]; then
+      printf '%s' "${1:-}" >> "${FM_SEND_LOG:-/dev/null}"
+    fi
+    exit 0
+    ;;
+  display-message)
+    for a in "$@"; do
+      case "$a" in *cursor_y*) printf '1\n'; exit 0 ;; esac
+    done
+    printf 'fakepane\n'
+    exit 0
+    ;;
+  capture-pane)
+    if [ "${FM_FAKE_TMUX_COMPOSER:-}" = pending ]; then
+      printf '╭──────────────╮\n│ leftover txt │\n╰──────────────╯\n'
+    else
+      printf '╭────╮\n│    │\n╰────╯\n'
+    fi
+    exit 0
+    ;;
+  list-windows) exit 0 ;;
+esac
+exit 0
+SH
+  chmod +x "$fakebin/tmux"
+}
+
+# fm_test_fake_ssh <fakebin> [name]
+# Records argv to FM_SSH_LOG, consumes stdin, exits FM_FAKE_SSH_RC (default 0).
+# Default name is fake-ssh so tests can point FM_SSH_BIN at it without
+# shadowing a real ssh on PATH.
+fm_test_fake_ssh() {
+  local fakebin=$1 name=${2:-fake-ssh}
+  cat > "$fakebin/$name" <<'SH'
+#!/usr/bin/env bash
+cat > /dev/null
+printf '%s\n' "$*" >> "${FM_SSH_LOG:-/dev/null}"
+exit "${FM_FAKE_SSH_RC:-0}"
+SH
+  chmod +x "$fakebin/$name"
+}
+
+# fm_test_fake_sleep_noop <fakebin>
+fm_test_fake_sleep_noop() {
+  local fakebin=$1
+  cat > "$fakebin/sleep" <<'SH'
+#!/usr/bin/env bash
+exit 0
+SH
+  chmod +x "$fakebin/sleep"
+}
+
+# fm_test_fake_sleep_log <fakebin>
+# Records each requested duration to FM_SLEEP_LOG instead of sleeping.
+fm_test_fake_sleep_log() {
+  local fakebin=$1
+  cat > "$fakebin/sleep" <<'SH'
+#!/usr/bin/env bash
+printf '%s\n' "${1:-}" >> "${FM_SLEEP_LOG:-/dev/null}"
+exit 0
+SH
+  chmod +x "$fakebin/sleep"
+}
+
+# --- spawn-world ------------------------------------------------------------
+
+# fm_test_spawn_home <home> [harness]
+# Minimal firstmate home layout plus watcher-liveness beat. Optional harness
+# pin is written to config/crew-harness.
+fm_test_spawn_home() {
+  local home=$1 harness=${2-}
+  mkdir -p "$home/data" "$home/projects" "$home/state" "$home/config"
+  touch "$home/state/.last-watcher-beat"
+  if [ -n "$harness" ]; then
+    printf '%s\n' "$harness" > "$home/config/crew-harness"
+  fi
+}
+
+# fm_test_spawn_brief <home> <id> [text]
+fm_test_spawn_brief() {
+  local home=$1 id=$2 text=${3:-brief for $2}
+  mkdir -p "$home/data/$id"
+  printf '%s\n' "$text" > "$home/data/$id/brief.md"
+}
+
+# fm_test_make_spawn_fakebin <dir> [extra-exit0-tool...]
+# Creates <dir>/fakebin with the spawn tmux stub, a no-op treehouse, and any
+# extra exit-0 tools. Echoes the fakebin path.
+fm_test_make_spawn_fakebin() {
+  local dir=$1 fakebin
+  shift
+  fakebin=$(fm_fakebin "$dir")
+  fm_test_fake_tmux_spawn "$fakebin"
+  fm_fake_exit0 "$fakebin" treehouse "$@"
+  printf '%s\n' "$fakebin"
+}
+
+# Drop-in name used by the spawn suites. Extra args are additional exit-0 tools
+# (gh, gh-axi, pi, ...).
+make_spawn_fakebin() {
+  fm_test_make_spawn_fakebin "$@"
+}
+
+# fm_test_run_spawn <home> <pane-path> <fakebin> [fm-spawn args...]
+# Common spawn env. Extra variables in the caller (GROK_HOME, FM_FAKE_LAUNCH_LOG,
+# CLAUDE_CONFIG_DIR, ...) are inherited. Does not add --mode/--yolo; ship tests
+# that need a delivery contract pass those flags themselves.
+fm_test_run_spawn() {
+  local home=$1 pane=$2 fakebin=$3
+  shift 3
+  FM_ROOT_OVERRIDE='' FM_HOME="$home" \
+    FM_STATE_OVERRIDE="$home/state" FM_DATA_OVERRIDE="$home/data" \
+    FM_PROJECTS_OVERRIDE="$home/projects" FM_CONFIG_OVERRIDE="$home/config" \
+    FM_SPAWN_NO_GUARD=1 FM_FAKE_PANE_PATH="$pane" TMUX="${TMUX:-fake,1,0}" \
+    PATH="$fakebin:$PATH" \
+    "$ROOT/bin/fm-spawn.sh" "$@" 2>&1
+}
+
+# --- send-world stubs -------------------------------------------------------
+
+# make_stubs <dir>
+# Send-world fakebin: send tmux + no-op sleep. Echoes the fakebin path.
+# Suites that need recording sleep, herdr, or ssh add those on top of this
+# fakebin (or replace sleep via fm_test_fake_sleep_log).
+make_stubs() {
+  local dir=$1 fakebin
+  fakebin=$(fm_fakebin "$dir")
+  fm_test_fake_tmux_send "$fakebin"
+  fm_test_fake_sleep_noop "$fakebin"
+  printf '%s\n' "$fakebin"
+}