@h-rig/cli 0.0.6-alpha.75 → 0.0.6-alpha.77

package/dist/src/commands/_operator-board.js

@@ -0,0 +1,730 @@
+// @bun
+// packages/cli/src/commands/_operator-board.ts
+import { ProcessTerminal, TUI, Text, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+
+// packages/cli/src/commands/_tui-theme.ts
+var RIG_PALETTE = {
+  ink: "#f2f3f6",
+  ink2: "#aeb0ba",
+  ink3: "#6c6e79",
+  ink4: "#44464f",
+  accent: "#ccff4d",
+  accentDim: "#a9d63f",
+  cyan: "#56d8ff",
+  red: "#ff5d5d",
+  yellow: "#ffd24d"
+};
+function hexToRgb(hex) {
+  const value = hex.replace("#", "");
+  return [
+    Number.parseInt(value.slice(0, 2), 16),
+    Number.parseInt(value.slice(2, 4), 16),
+    Number.parseInt(value.slice(4, 6), 16)
+  ];
+}
+function fg(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
+}
+var ink = fg(RIG_PALETTE.ink);
+var ink2 = fg(RIG_PALETTE.ink2);
+var ink3 = fg(RIG_PALETTE.ink3);
+var ink4 = fg(RIG_PALETTE.ink4);
+var accent = fg(RIG_PALETTE.accent);
+var accentDim = fg(RIG_PALETTE.accentDim);
+var cyan = fg(RIG_PALETTE.cyan);
+var red = fg(RIG_PALETTE.red);
+var yellow = fg(RIG_PALETTE.yellow);
+function bold(text) {
+  return `\x1B[1m${text}\x1B[22m`;
+}
+function statusColor(status) {
+  switch (status) {
+    case "running":
+      return accent;
+    case "preparing":
+    case "created":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return cyan;
+    case "needs-attention":
+    case "needs_attention":
+      return yellow;
+    case "failed":
+      return red;
+    default:
+      return ink3;
+  }
+}
+var RIG_SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var DRONE_ART = [
+  "  .-=-.                   .-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'._               _.'-=-'   ",
+  "        '._           _.'         ",
+  "           '=$$$$$$$=.'           ",
+  "          =$$$$$$$$$$$=           ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "        $$$@@        @@$$$        ",
+  "        $$@    ?     @$$$         ",
+  "        $$$@   '-'   @$$$         ",
+  "        $$$@@        @@$$$        ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "          =$$$$$$$$$$$=           ",
+  "           '=$$$$$$$=.'           ",
+  "        _.'           '._         ",
+  "  .-=-.'                 '.-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'                   '-=-'   "
+];
+var BLADE_FRAMES = ["---", "\\\\\\", "|||", "///"];
+var EYE_FRAMES = ["@", "o", "."];
+function droneCharColor(char) {
+  if (char === "$" || char === "@")
+    return accent;
+  if (char === "=" || char === "%")
+    return accentDim;
+  if (char === "\\" || char === "/")
+    return ink3;
+  return ink4;
+}
+function renderDroneFrame(tick) {
+  const blade = BLADE_FRAMES[Math.floor(tick / 4) % BLADE_FRAMES.length];
+  const pulse = Math.sin(tick * 0.07);
+  const eye = pulse > 0.45 ? EYE_FRAMES[0] : pulse > -0.1 ? EYE_FRAMES[1] : EYE_FRAMES[2];
+  return DRONE_ART.map((line) => {
+    let out = "";
+    let index = 0;
+    while (index < line.length) {
+      if (line.startsWith("!!!", index)) {
+        out += cyan(blade);
+        index += 3;
+        continue;
+      }
+      const char = line[index];
+      if (char === "?") {
+        out += bold(cyan(eye));
+      } else if (char !== " ") {
+        out += droneCharColor(char)(char);
+      } else {
+        out += " ";
+      }
+      index += 1;
+    }
+    return out;
+  });
+}
+var DRONE_WIDTH = DRONE_ART[0].length;
+var DRONE_HEIGHT = DRONE_ART.length;
+
+// packages/cli/src/commands/_server-client.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+
+// packages/cli/src/commands/_server-client.ts
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+
+// packages/cli/src/commands/_connection-state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+function resolveGlobalConnectionsPath(env = process.env) {
+  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
+  if (explicit)
+    return resolve(explicit);
+  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
+  if (stateDir)
+    return resolve(stateDir, "connections.json");
+  return resolve(homedir(), ".rig", "connections.json");
+}
+function resolveRepoConnectionPath(projectRoot) {
+  return resolve(projectRoot, ".rig", "state", "connection.json");
+}
+function readJsonFile(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new CliError(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1, { hint: "Fix or delete that file, then re-select a server with `rig server use <alias|local>`." });
+  }
+}
+function writeJsonFile(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function normalizeConnection(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  if (record.kind === "local")
+    return { kind: "local", mode: "auto" };
+  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
+    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
+    return { kind: "remote", baseUrl };
+  }
+  return null;
+}
+function readGlobalConnections(options = {}) {
+  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
+  const payload = readJsonFile(path);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return { connections: {} };
+  }
+  const rawConnections = payload.connections;
+  const connections = {};
+  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
+    for (const [alias, raw] of Object.entries(rawConnections)) {
+      const connection = normalizeConnection(raw);
+      if (connection)
+        connections[alias] = connection;
+    }
+  }
+  return { connections };
+}
+function readRepoConnection(projectRoot) {
+  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
+  if (!selected)
+    return null;
+  return {
+    selected,
+    project: typeof record.project === "string" ? record.project : undefined,
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined
+  };
+}
+function writeRepoConnection(projectRoot, state) {
+  writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
+}
+function resolveSelectedConnection(projectRoot, options = {}) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return null;
+  if (repo.selected === "local")
+    return { alias: "local", connection: { kind: "local", mode: "auto" }, serverProjectRoot: repo.serverProjectRoot };
+  const global = readGlobalConnections(options);
+  const connection = global.connections[repo.selected];
+  if (!connection) {
+    throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
+  }
+  return { alias: repo.selected, connection, serverProjectRoot: repo.serverProjectRoot };
+}
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
+}
+
+// packages/cli/src/commands/_server-client.ts
+var scopedGitHubBearerTokens = new Map;
+var serverPhaseListener = null;
+function reportServerPhase(label) {
+  serverPhaseListener?.(label);
+}
+function cleanToken(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function readPrivateRemoteSessionToken(projectRoot) {
+  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
+  if (!existsSync2(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
+  } catch {
+    return null;
+  }
+}
+function readGitHubBearerTokenForRemote(projectRoot) {
+  const scopedKey = resolve2(projectRoot);
+  if (scopedGitHubBearerTokens.has(scopedKey))
+    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
+  const privateSession = readPrivateRemoteSessionToken(projectRoot);
+  if (privateSession)
+    return privateSession;
+  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
+}
+function readStoredGitHubAuthToken(projectRoot) {
+  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
+  if (!existsSync2(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
+  } catch {
+    return null;
+  }
+}
+function readLocalConnectionFallbackToken(projectRoot) {
+  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
+}
+async function ensureServerForCli(projectRoot) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (selected?.connection.kind === "remote") {
+      reportServerPhase(`Connecting to ${selected.alias}\u2026`);
+      const authToken = readGitHubBearerTokenForRemote(projectRoot);
+      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      return {
+        baseUrl: selected.connection.baseUrl,
+        authToken,
+        connectionKind: "remote",
+        serverProjectRoot
+      };
+    }
+    reportServerPhase("Starting local Rig server\u2026");
+    const connection = await ensureLocalRigServerConnection(projectRoot);
+    return {
+      baseUrl: connection.baseUrl,
+      authToken: connection.authToken ?? readLocalConnectionFallbackToken(projectRoot),
+      connectionKind: "local",
+      serverProjectRoot: resolve2(projectRoot)
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new CliError(error.message, 1);
+    }
+    throw error;
+  }
+}
+async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug)
+    return null;
+  try {
+    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
+      headers: mergeHeaders(undefined, authToken)
+    });
+    if (!response.ok)
+      return null;
+    const payload = await response.json();
+    const project = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : null;
+    const checkouts = Array.isArray(project?.checkouts) ? project.checkouts : [];
+    const latestCheckout = [...checkouts].reverse().find((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.path === "string"));
+    const path = typeof latestCheckout?.path === "string" && latestCheckout.path.trim() ? latestCheckout.path.trim() : null;
+    if (path)
+      writeRepoServerProjectRoot(projectRoot, path);
+    return path;
+  } catch {
+    return null;
+  }
+}
+function mergeHeaders(headers, authToken) {
+  const merged = new Headers(headers);
+  if (authToken) {
+    merged.set("authorization", `Bearer ${authToken}`);
+  }
+  return merged;
+}
+function diagnosticMessage(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const diagnostics = Array.isArray(record.diagnostics) ? record.diagnostics : [];
+  const messages = diagnostics.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      return [];
+    const diagnostic = entry;
+    const kind = typeof diagnostic.kind === "string" ? diagnostic.kind : "task-source";
+    const message = typeof diagnostic.message === "string" ? diagnostic.message : null;
+    return message ? [`${kind}: ${message}`] : [];
+  });
+  return messages.length > 0 ? messages.join("; ") : null;
+}
+var serverReachabilityCache = new Map;
+async function probeServerReachability(baseUrl, authToken) {
+  try {
+    const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/api/server/status`, {
+      headers: mergeHeaders(undefined, authToken),
+      signal: AbortSignal.timeout(1500)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function cachedServerReachability(projectRoot, baseUrl, authToken) {
+  const key = resolve2(projectRoot);
+  const cached = serverReachabilityCache.get(key);
+  if (cached)
+    return cached;
+  const probe = probeServerReachability(baseUrl, authToken);
+  serverReachabilityCache.set(key, probe);
+  return probe;
+}
+function describeSelectedServer(projectRoot, server) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (selected) {
+      return {
+        alias: selected.alias,
+        target: selected.connection.kind === "remote" ? selected.connection.baseUrl : server.baseUrl
+      };
+    }
+  } catch {}
+  return { alias: server.connectionKind === "remote" ? "remote" : "local", target: server.baseUrl };
+}
+async function buildServerFailureContext(projectRoot, server) {
+  const { alias, target } = describeSelectedServer(projectRoot, server);
+  const reachable = await cachedServerReachability(projectRoot, server.baseUrl, server.authToken);
+  const reachability = reachable ? "server is reachable" : "server is unreachable";
+  return {
+    contextLine: `Currently connected to: ${alias} at ${target} (${reachability}).`,
+    hint: "Check the selected server with `rig server status`, or switch with `rig server use <alias|local>`."
+  };
+}
+async function requestServerJson(context, pathname, init = {}) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const headers = mergeHeaders(init.headers, server.authToken);
+  if (server.serverProjectRoot)
+    headers.set("x-rig-project-root", server.serverProjectRoot);
+  reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
+  let response;
+  try {
+    response = await fetch(`${server.baseUrl}${pathname}`, {
+      ...init,
+      headers
+    });
+  } catch (error) {
+    const failure = await buildServerFailureContext(context.projectRoot, server);
+    throw new CliError(`Rig server request failed: ${error instanceof Error ? error.message : String(error)}
+${failure.contextLine}`, 1, { hint: failure.hint });
+  }
+  const text = await response.text();
+  const payload = text.trim().length > 0 ? (() => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  })() : null;
+  if (!response.ok) {
+    const diagnostics = diagnosticMessage(payload);
+    const detail = diagnostics ?? (text || response.statusText);
+    const failure = await buildServerFailureContext(context.projectRoot, server);
+    throw new CliError(`Rig server request failed (${response.status}): ${detail}
+${failure.contextLine}`, 1, { hint: failure.hint });
+  }
+  return payload;
+}
+async function listRunsViaServer(context, options = {}) {
+  const url = new URL("http://rig.local/api/runs");
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  const runs = Array.isArray(payload) ? payload : payload && typeof payload === "object" && !Array.isArray(payload) && Array.isArray(payload.runs) ? payload.runs : [];
+  return runs.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+}
+var RESUMABLE_RUN_STATUSES = new Set([
+  "created",
+  "preparing",
+  "running",
+  "validating",
+  "reviewing",
+  "stopped",
+  "failed",
+  "needs-attention",
+  "needs_attention"
+]);
+async function resolveServerConnectionLabel(projectRoot) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (!selected)
+      return "no server selected";
+    if (selected.connection.kind === "remote") {
+      return selected.connection.baseUrl.replace(/^https?:\/\//, "");
+    }
+    return `local (${selected.alias})`;
+  } catch {
+    return "no server selected";
+  }
+}
+async function stopRunViaServer(context, runId) {
+  const payload = await requestServerJson(context, "/api/runs/stop", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ runId })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true, runId };
+}
+
+// packages/cli/src/commands/_cli-format.ts
+import { log, note } from "@clack/prompts";
+import pc from "picocolors";
+
+// packages/cli/src/commands/_async-ui.ts
+import pc2 from "picocolors";
+var DONE_SYMBOL = pc2.green("\u25C7");
+var FAIL_SYMBOL = pc2.red("\u25A0");
+
+// packages/cli/src/commands/inbox.ts
+async function listInboxRecords(context, kind, filters) {
+  const params = new URLSearchParams;
+  if (filters.run)
+    params.set("runId", filters.run);
+  if (filters.task)
+    params.set("taskId", filters.task);
+  const query = params.size > 0 ? `?${params.toString()}` : "";
+  const payload = await requestServerJson(context, `/api/inbox/${kind}${query}`);
+  const records = Array.isArray(payload) ? payload : [];
+  return filters.pendingOnly ? records.filter((entry) => (entry.status ?? "pending") !== "resolved") : records;
+}
+async function readPendingInboxCounts(context) {
+  try {
+    const [approvals, inputs] = await Promise.all([
+      listInboxRecords(context, "approvals", { pendingOnly: true }),
+      listInboxRecords(context, "inputs", { pendingOnly: true })
+    ]);
+    return { approvals: approvals.length, inputs: inputs.length };
+  } catch {
+    return null;
+  }
+}
+
+// packages/cli/src/commands/_operator-board.ts
+var BOARD_REFRESH_MS = 5000;
+var BOARD_TICK_MS = 120;
+function normalizeRuns(payload) {
+  return payload.map((run) => ({
+    runId: typeof run.runId === "string" ? run.runId : "",
+    status: typeof run.status === "string" ? run.status : "unknown",
+    title: String(run.title ?? run.taskId ?? "untitled")
+  })).filter((run) => run.runId);
+}
+
+class RunsList {
+  runs = [];
+  selected = 0;
+  loading = true;
+  tick = 0;
+  moveSelection(delta) {
+    if (this.runs.length === 0)
+      return;
+    this.selected = Math.max(0, Math.min(this.runs.length - 1, this.selected + delta));
+  }
+  selectedRun() {
+    return this.runs[this.selected] ?? null;
+  }
+  setRuns(runs) {
+    const previous = this.selectedRun()?.runId;
+    this.runs = runs;
+    if (previous) {
+      const index = runs.findIndex((run) => run.runId === previous);
+      this.selected = index >= 0 ? index : Math.min(this.selected, Math.max(0, runs.length - 1));
+    } else {
+      this.selected = Math.min(this.selected, Math.max(0, runs.length - 1));
+    }
+    this.loading = false;
+  }
+  invalidate() {}
+  render(width) {
+    if (this.loading) {
+      const frame = renderDroneFrame(this.tick);
+      const spinner = RIG_SPINNER_FRAMES[this.tick % RIG_SPINNER_FRAMES.length];
+      const pad = Math.max(0, Math.floor((width - 34) / 2));
+      return [
+        "",
+        ...frame.map((line) => " ".repeat(pad) + line),
+        "",
+        " ".repeat(Math.max(0, Math.floor((width - 24) / 2))) + accent(spinner) + ink3(" contacting the fleet\u2026"),
+        ""
+      ];
+    }
+    if (this.runs.length === 0) {
+      const frame = renderDroneFrame(this.tick);
+      const pad = Math.max(0, Math.floor((width - 34) / 2));
+      return [
+        "",
+        ...frame.map((line) => " ".repeat(pad) + line),
+        "",
+        " ".repeat(Math.max(0, Math.floor((width - 38) / 2))) + ink2("no runs yet \u2014 ") + accent("rig task run --next") + ink2(" launches one"),
+        ""
+      ];
+    }
+    const maxVisible = 16;
+    const start = Math.max(0, Math.min(this.selected - Math.floor(maxVisible / 2), this.runs.length - maxVisible));
+    const visible = this.runs.slice(start, start + maxVisible);
+    const lines = visible.map((run, index) => {
+      const absolute = start + index;
+      const isSelected = absolute === this.selected;
+      const dot = statusColor(run.status)(isSelected ? "\u25CF" : "\xB7");
+      const id = run.runId.slice(0, 8);
+      const status = statusColor(run.status)(run.status.padEnd(16));
+      const title = truncateToWidth(run.title, Math.max(8, width - 36));
+      const row = ` ${dot} ${isSelected ? bold(ink(id)) : ink3(id)}  ${status} ${isSelected ? ink(title) : ink2(title)}`;
+      return isSelected ? accent("\u258C") + row : " " + row;
+    });
+    if (this.runs.length > maxVisible) {
+      lines.push(ink4(`   ${this.selected + 1}/${this.runs.length}`));
+    }
+    return ["", ...lines, ""];
+  }
+}
+function hairline(width) {
+  return ink4("\u2500".repeat(Math.max(0, width)));
+}
+
+class Rule {
+  invalidate() {}
+  render(width) {
+    return [hairline(width)];
+  }
+}
+async function runOperatorBoard(context) {
+  const terminal = new ProcessTerminal;
+  const tui = new TUI(terminal);
+  const list = new RunsList;
+  const header = new Text("");
+  const footer = new Text("");
+  let serverLabel = "resolving server\u2026";
+  let inboxCounts = null;
+  let notice = null;
+  let tick = 0;
+  const renderHeader = (width = 100) => {
+    header.setText(` ${accent("\u258D")}${bold(ink("rig"))} ${ink3("\u2014 operate the drones")}   ${ink4("\xB7")} ${cyan(serverLabel)}`);
+  };
+  const renderFooter = () => {
+    const pending = inboxCounts && inboxCounts.approvals + inboxCounts.inputs > 0 ? `${RIG_SPINNER_FRAMES[tick % RIG_SPINNER_FRAMES.length]} ${inboxCounts.approvals + inboxCounts.inputs} inbox gate${inboxCounts.approvals + inboxCounts.inputs === 1 ? "" : "s"} waiting \u2014 rig inbox` : "fleet idle gates clear";
+    const status = notice ?? pending;
+    footer.setText([
+      ` ${inboxCounts && inboxCounts.approvals + inboxCounts.inputs > 0 ? accentDim(status) : ink4(status)}`,
+      ` ${accent("enter")}${ink3(" attach (full session, live)")}  ${accent("x")}${ink3(" stop")}  ${accent("r")}${ink3(" refresh")}  ${accent("q")}${ink3(" quit")}`
+    ].join(`
+`));
+  };
+  renderHeader();
+  renderFooter();
+  tui.addChild(header);
+  tui.addChild(new Rule);
+  tui.addChild(list);
+  tui.addChild(new Rule);
+  tui.addChild(footer);
+  let stopped = false;
+  let outcome = { action: "quit" };
+  const finish = (result) => {
+    if (stopped)
+      return;
+    stopped = true;
+    outcome = result;
+    tui.stop();
+  };
+  const refresh = async () => {
+    try {
+      const [runs, counts] = await Promise.all([
+        listRunsViaServer(context),
+        readPendingInboxCounts(context)
+      ]);
+      list.setRuns(normalizeRuns(runs));
+      inboxCounts = counts;
+      notice = null;
+    } catch (error) {
+      list.loading = false;
+      notice = `server unreachable: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    renderFooter();
+    tui.requestRender();
+  };
+  resolveServerConnectionLabel(context.projectRoot).then((label) => {
+    serverLabel = label;
+    renderHeader();
+    tui.requestRender();
+  }).catch(() => {});
+  tui.addInputListener((data) => {
+    if (matchesKey(data, "up") || data === "k") {
+      list.moveSelection(-1);
+      tui.requestRender();
+      return { consume: true };
+    }
+    if (matchesKey(data, "down") || data === "j") {
+      list.moveSelection(1);
+      tui.requestRender();
+      return { consume: true };
+    }
+    if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+      const run = list.selectedRun();
+      if (run)
+        finish({ action: "attach", runId: run.runId });
+      return { consume: true };
+    }
+    if (data === "x") {
+      const run = list.selectedRun();
+      if (run) {
+        notice = `stop requested for ${run.runId.slice(0, 8)}\u2026`;
+        renderFooter();
+        tui.requestRender();
+        stopRunViaServer(context, run.runId).then(() => refresh()).catch(() => refresh());
+      }
+      return { consume: true };
+    }
+    if (data === "r") {
+      refresh();
+      return { consume: true };
+    }
+    if (data === "q" || matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+      finish({ action: "quit" });
+      return { consume: true };
+    }
+    return { consume: true };
+  });
+  const animation = setInterval(() => {
+    tick += 1;
+    list.tick = tick;
+    if (list.loading || list.runs.length === 0 || inboxCounts && inboxCounts.approvals + inboxCounts.inputs > 0) {
+      renderFooter();
+      tui.requestRender();
+    }
+  }, BOARD_TICK_MS);
+  const refreshTimer = setInterval(() => {
+    refresh();
+  }, BOARD_REFRESH_MS);
+  tui.start();
+  refresh();
+  await new Promise((resolve3) => {
+    const poll = setInterval(() => {
+      if (stopped) {
+        clearInterval(poll);
+        resolve3();
+      }
+    }, 50);
+  });
+  clearInterval(animation);
+  clearInterval(refreshTimer);
+  return outcome;
+}
+async function runOperatorBoardLoop(context, attach) {
+  for (;; ) {
+    const outcome = await runOperatorBoard(context);
+    if (outcome.action === "quit")
+      return;
+    await attach(outcome.runId);
+  }
+}
+export {
+  runOperatorBoardLoop,
+  runOperatorBoard
+};