feat(tmux): implement multi-socket worker tally, regex auto-approver, and onboard TUI
- bin/tmux_auto_approver.py: multi-socket worker discovery across user and netns sockets - Regex matching engine with 7 terminal prompt rules and hard security guardrails - bin/box-onboard-tui.py: dedicated 4-tab curses TUI for fleet connects, tmux workers, rules, and audit logs - Audit logging stream in logs/tmux/auto-approvals.jsonl and state in .state/ - Unit test suites covering engine, rules, guardrails, and curses rendering
This commit is contained in:
operator
Executable
+720
@@ -0,0 +1,720 @@
|
||||
#!/usr/bin/env python3
|
||||
"""box-onboard-tui.py — Dedicated interactive TUI for NetVM Onboard Connects, Tmux Workers, and Auto-Approvals.
|
||||
|
||||
Features 4 bridged surfaces:
|
||||
[1 / F1] Onboard Connects:
|
||||
Live inventory of fleet nodes & client onboarding pipelines,
|
||||
invite codes, token feeding urgency, OTP verification, and salvage dispatch.
|
||||
[2 / F2] Tmux Workers & Tally:
|
||||
Multi-socket worker inventory (/tmp/tmux-1000/default, lte, muse.sock, netns socks),
|
||||
active panes, live pane scrollback preview, worker spawning, and session killing.
|
||||
[3 / F3] Auto-Approvals & Regex Matcher:
|
||||
Master auto-approval toggle, per-agent policies, terminal regex rule engine
|
||||
(Muse Code runs, A/B/C choices, 1/2 menus, y/n confirmations), and interactive regex tester.
|
||||
[4 / F4] Box Surface & Logs:
|
||||
Surface link with https://box.muse-dev.online/, real-time audit log stream,
|
||||
and search/filter capabilities.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import curses
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from dataclasses import asdict
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional, Tuple
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parent.parent
|
||||
BIN_DIR = REPO_ROOT / "bin"
|
||||
sys.path.insert(0, str(BIN_DIR))
|
||||
|
||||
try:
|
||||
import tmux_auto_approver
|
||||
from tmux_auto_approver import (
|
||||
AutoApproverRunner,
|
||||
AutoApproverState,
|
||||
DEFAULT_RULES,
|
||||
FLEET_AGENTS,
|
||||
MatchRule,
|
||||
RegexApproverEngine,
|
||||
gather_tmux_tally,
|
||||
run_tmux_cmd,
|
||||
capture_pane_text,
|
||||
)
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
try:
|
||||
import onboard_pipeline
|
||||
from onboard_pipeline import get_all_connects, OnboardState
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
|
||||
class BoxOnboardTUI:
|
||||
def __init__(self, stdscr: curses.window):
|
||||
self.stdscr = stdscr
|
||||
self.current_tab = 0 # 0: Onboard, 1: Tmux, 2: Auto-Approvals, 3: Surface & Logs
|
||||
self.tabs = [
|
||||
"1: ONBOARD CONNECTS",
|
||||
"2: TMUX WORKERS & TALLY",
|
||||
"3: AUTO-APPROVALS & REGEX",
|
||||
"4: SURFACE & LOGS",
|
||||
]
|
||||
|
||||
# Curses initialization
|
||||
try:
|
||||
curses.curs_set(0)
|
||||
except Exception:
|
||||
pass
|
||||
self.stdscr.nodelay(True)
|
||||
self.stdscr.keypad(True)
|
||||
|
||||
if hasattr(curses, "set_escdelay"):
|
||||
try:
|
||||
curses.set_escdelay(25)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
try:
|
||||
curses.mousemask(curses.ALL_MOUSE_EVENTS | curses.REPORT_MOUSE_POSITION)
|
||||
if hasattr(curses, "mouseinterval"):
|
||||
curses.mouseinterval(0)
|
||||
sys.stdout.write("\033[?1000h\033[?1002h\033[?1006h\033[?2004h")
|
||||
sys.stdout.flush()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
self._init_colors()
|
||||
|
||||
# Shared State
|
||||
self.approver_state = AutoApproverState.load()
|
||||
self.tally = gather_tmux_tally(self.approver_state)
|
||||
self.connects: List[Dict[str, Any]] = []
|
||||
self._refresh_connects()
|
||||
|
||||
# Selection indices
|
||||
self.sel_connect_idx = 0
|
||||
self.sel_pane_idx = 0
|
||||
self.sel_rule_idx = 0
|
||||
self.sel_log_scroll = 0
|
||||
|
||||
# UI State & Modals
|
||||
self.modal: Optional[str] = None # "spawn_worker", "submit_otp", "test_regex", "help"
|
||||
self.modal_input_buf = ""
|
||||
self.modal_input_cursor = 0
|
||||
self.toast_msg = "Welcome to Box Onboard & Tmux Console. Press ? for help."
|
||||
self.toast_level = "info"
|
||||
self.toast_time = time.time() + 4.0
|
||||
|
||||
# Interactive Regex Matcher state (Tab 3)
|
||||
self.test_text_buf = "Would you like to run the following\n\n $ box fleet status\n\n› 1. Yes, proceed (y)\n 2. No, and tell Muse Code what to do"
|
||||
self.test_match_verdict: Optional[Dict[str, Any]] = None
|
||||
self._eval_test_match()
|
||||
|
||||
# Runner instance for one-shot runs
|
||||
self.runner = AutoApproverRunner()
|
||||
self.last_auto_poll = 0.0
|
||||
|
||||
def _init_colors(self) -> None:
|
||||
try:
|
||||
curses.start_color()
|
||||
curses.use_default_colors()
|
||||
curses.init_pair(1, curses.COLOR_CYAN, -1) # Accent / Info
|
||||
curses.init_pair(2, curses.COLOR_YELLOW, -1) # Warning / Agent
|
||||
curses.init_pair(3, curses.COLOR_GREEN, -1) # Success / Active
|
||||
curses.init_pair(4, curses.COLOR_RED, -1) # Error / Blocked
|
||||
curses.init_pair(5, curses.COLOR_MAGENTA, -1) # Special / Category
|
||||
curses.init_pair(6, curses.COLOR_BLACK, curses.COLOR_CYAN) # Header Selected
|
||||
curses.init_pair(7, curses.COLOR_BLACK, curses.COLOR_WHITE) # Selected Row
|
||||
curses.init_pair(8, curses.COLOR_BLACK, curses.COLOR_YELLOW) # Warning Banner
|
||||
curses.init_pair(9, curses.COLOR_WHITE, -1) # Dim / Normal
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def _attr(self, name: str) -> int:
|
||||
try:
|
||||
mapping = {
|
||||
"normal": curses.color_pair(0),
|
||||
"cyan": curses.color_pair(1) | curses.A_BOLD,
|
||||
"yellow": curses.color_pair(2) | curses.A_BOLD,
|
||||
"green": curses.color_pair(3) | curses.A_BOLD,
|
||||
"red": curses.color_pair(4) | curses.A_BOLD,
|
||||
"magenta": curses.color_pair(5) | curses.A_BOLD,
|
||||
"head_sel": curses.color_pair(6) | curses.A_BOLD,
|
||||
"row_sel": curses.color_pair(7) | curses.A_BOLD,
|
||||
"warn_banner": curses.color_pair(8) | curses.A_BOLD,
|
||||
"dim": curses.color_pair(9) | curses.A_DIM,
|
||||
}
|
||||
return mapping.get(name, 0)
|
||||
except Exception:
|
||||
return 0
|
||||
|
||||
def set_toast(self, msg: str, level: str = "info") -> None:
|
||||
self.toast_msg = msg
|
||||
self.toast_level = level
|
||||
self.toast_time = time.time() + 4.0
|
||||
|
||||
def _refresh_connects(self) -> None:
|
||||
try:
|
||||
self.connects = get_all_connects(fast=True)
|
||||
except Exception:
|
||||
self.connects = []
|
||||
|
||||
def _refresh_tally(self) -> None:
|
||||
self.approver_state = AutoApproverState.load()
|
||||
self.tally = gather_tmux_tally(self.approver_state)
|
||||
|
||||
def _eval_test_match(self) -> None:
|
||||
engine = RegexApproverEngine([MatchRule(**r) for r in self.approver_state.rules])
|
||||
v = engine.evaluate(self.test_text_buf)
|
||||
self.test_match_verdict = {
|
||||
"matched": v.matched,
|
||||
"rule_name": v.rule_name,
|
||||
"key": v.key,
|
||||
"category": v.category,
|
||||
"press_enter": v.press_enter,
|
||||
"reason": v.reason,
|
||||
"is_blocked": v.is_blocked,
|
||||
"blocked_reason": v.blocked_reason,
|
||||
"excerpt": v.excerpt,
|
||||
}
|
||||
|
||||
# =================================================================
|
||||
# Render Helpers
|
||||
# =================================================================
|
||||
|
||||
def safe_addstr(self, y: int, x: int, text: str, attr: int = 0) -> None:
|
||||
h, w = self.stdscr.getmaxyx()
|
||||
if 0 <= y < h and 0 <= x < w:
|
||||
avail = max(0, w - x - 1)
|
||||
try:
|
||||
self.stdscr.addstr(y, x, text[:avail], attr)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def _render_header(self, w: int) -> None:
|
||||
# Title bar
|
||||
self.safe_addstr(0, 0, " " * w, self._attr("header_sel"))
|
||||
title = " BOX ONBOARD & TMUX CONSOLE [https://box.muse-dev.online/] "
|
||||
self.safe_addstr(0, 1, title, self._attr("header_sel"))
|
||||
|
||||
# Master auto-approve badge in header
|
||||
master_tag = " [● AUTO-APPROVE: ON] " if self.approver_state.global_enabled else " [○ AUTO-APPROVE: OFF] "
|
||||
m_attr = self._attr("green") if self.approver_state.global_enabled else self._attr("warn_banner")
|
||||
self.safe_addstr(0, max(len(title) + 2, w - len(master_tag) - 2), master_tag, m_attr)
|
||||
|
||||
# Tab navigation bar
|
||||
self.safe_addstr(1, 0, " " * w, self._attr("dim"))
|
||||
col = 1
|
||||
for idx, tab_name in enumerate(self.tabs):
|
||||
is_cur = (idx == self.current_tab)
|
||||
pill = f" [{tab_name}] "
|
||||
attr = self._attr("header_sel") if is_cur else self._attr("dim")
|
||||
self.safe_addstr(1, col, pill, attr)
|
||||
col += len(pill) + 2
|
||||
|
||||
self.safe_addstr(2, 0, "─" * w, self._attr("dim"))
|
||||
|
||||
def _render_footer(self, h: int, w: int) -> None:
|
||||
y = h - 2
|
||||
self.safe_addstr(y, 0, "─" * w, self._attr("dim"))
|
||||
|
||||
# Toast or Hints
|
||||
if time.time() < self.toast_time:
|
||||
attr = self._attr("green") if self.toast_level == "success" else (self._attr("warn_banner") if self.toast_level == "warn" else self._attr("cyan"))
|
||||
self.safe_addstr(y + 1, 1, f" {self.toast_msg} ", attr)
|
||||
else:
|
||||
if self.current_tab == 0:
|
||||
hints = " [ONBOARD] 1-4: Tabs j/k: Select n: New Onboard o: Submit OTP s: Salvage WO r: Refresh ?: Help q: Quit"
|
||||
elif self.current_tab == 1:
|
||||
hints = " [TMUX] 1-4: Tabs j/k: Select t: Toggle Auto-Approve n: Spawn k: Kill p: Prune Enter: Full Tail q: Quit"
|
||||
elif self.current_tab == 2:
|
||||
hints = " [RULES] 1-4: Tabs Space/a: Toggle Master m: Test Matcher j/k: Rules o: Trigger Once q: Quit"
|
||||
else:
|
||||
hints = " [LOGS] 1-4: Tabs j/k: Scroll e: Sync Box API r: Refresh q: Quit"
|
||||
self.safe_addstr(y + 1, 1, hints[:w - 2], self._attr("dim"))
|
||||
|
||||
# =================================================================
|
||||
# Tab 1: Onboard Connects
|
||||
# =================================================================
|
||||
|
||||
def _render_tab_onboard(self, h: int, w: int) -> None:
|
||||
start_y = 3
|
||||
max_rows = h - 7
|
||||
|
||||
self.safe_addstr(start_y, 2, "ACTIVE FLEET AGENTS & CLIENT ONBOARDING CONNECTS", self._attr("cyan"))
|
||||
self.safe_addstr(start_y + 1, 2, "─" * (w - 4), self._attr("dim"))
|
||||
|
||||
hdr = f" {'NODE':<8} {'TYPE':<16} {'STAGE / STATUS':<18} {'CDP':<8} {'INVITE':<10} {'ROLE / DETAIL'}"
|
||||
self.safe_addstr(start_y + 2, 2, hdr, self._attr("bold"))
|
||||
self.safe_addstr(start_y + 3, 2, "─" * (w - 4), self._attr("dim"))
|
||||
|
||||
if not self.connects:
|
||||
self.safe_addstr(start_y + 4, 4, "(No onboard records found. Press 'n' to initiate client onboarding)", self._attr("dim"))
|
||||
return
|
||||
|
||||
for idx, c in enumerate(self.connects[:max_rows]):
|
||||
row_y = start_y + 4 + idx
|
||||
is_sel = (idx == self.sel_connect_idx)
|
||||
node = c.get("node", "")
|
||||
t_str = c.get("type", "")
|
||||
st_str = c.get("stage", c.get("status", ""))
|
||||
cdp = str(c.get("cdp_port") or "-")
|
||||
code = c.get("invite_code") or "-"
|
||||
role = c.get("role") or c.get("detail") or c.get("email") or ""
|
||||
|
||||
line = f" {node:<8} {t_str:<16} {st_str:<18} {cdp:<8} {code:<10} {role}"
|
||||
attr = self._attr("selected") if is_sel else (self._attr("green") if "active" in st_str or "completed" in st_str else self._attr("normal"))
|
||||
self.safe_addstr(row_y, 2, " " * (w - 4), attr if is_sel else 0)
|
||||
self.safe_addstr(row_y, 2, line, attr)
|
||||
|
||||
# =================================================================
|
||||
# Tab 2: Tmux Workers & Tally
|
||||
# =================================================================
|
||||
|
||||
def _render_tab_tmux(self, h: int, w: int) -> None:
|
||||
start_y = 3
|
||||
split_h = max(6, (h - 6) // 2)
|
||||
|
||||
# Header summary
|
||||
summary = f"TMUX WORKER TALLY — {self.tally.total_sessions} Sessions · {self.tally.total_panes} Panes · {self.tally.active_workers} Active across {self.tally.total_sockets} Sockets"
|
||||
self.safe_addstr(start_y, 2, summary, self._attr("cyan"))
|
||||
|
||||
hdr = f" {'Socket':<18} {'Session':<14} {'Pane':<6} {'PID':<8} {'Agent':<6} {'Cmd':<16} {'Auto-Approve'}"
|
||||
self.safe_addstr(start_y + 1, 2, hdr, self._attr("bold"))
|
||||
self.safe_addstr(start_y + 2, 2, "─" * (w - 4), self._attr("dim"))
|
||||
|
||||
panes = self.tally.panes
|
||||
table_rows = split_h - 3
|
||||
|
||||
if not panes:
|
||||
self.safe_addstr(start_y + 3, 4, "(No active tmux sessions found)", self._attr("dim"))
|
||||
else:
|
||||
for idx, p in enumerate(panes[:table_rows]):
|
||||
row_y = start_y + 3 + idx
|
||||
is_sel = (idx == self.sel_pane_idx)
|
||||
sock_short = os.path.basename(p.socket)
|
||||
auto_str = "[AUTO: ON]" if p.auto_approve else "[AUTO: OFF]"
|
||||
auto_attr = self._attr("green") if p.auto_approve else self._attr("dim")
|
||||
|
||||
line = f" {sock_short:<18} {p.session[:13]:<14} {p.pane_id:<6} {p.pane_pid:<8} {p.agent_node:<6} {p.current_command[:15]:<16} {auto_str}"
|
||||
attr = self._attr("selected") if is_sel else self._attr("normal")
|
||||
self.safe_addstr(row_y, 2, " " * (w - 4), attr if is_sel else 0)
|
||||
self.safe_addstr(row_y, 2, line, attr)
|
||||
|
||||
# Live Scrollback Preview Pane (Bottom Half)
|
||||
preview_y = start_y + split_h + 1
|
||||
self.safe_addstr(preview_y - 1, 2, "─" * (w - 4), self._attr("dim"))
|
||||
|
||||
sel_pane = panes[self.sel_pane_idx] if (panes and 0 <= self.sel_pane_idx < len(panes)) else None
|
||||
if sel_pane:
|
||||
prev_hdr = f"LIVE SCROLLBACK PREVIEW — {sel_pane.session}:{sel_pane.pane_id} ({sel_pane.current_command}) on {sel_pane.socket}"
|
||||
self.safe_addstr(preview_y, 2, prev_hdr, self._attr("yellow"))
|
||||
|
||||
txt = capture_pane_text(sel_pane.socket, sel_pane.pane_id, lines=h - preview_y - 4)
|
||||
p_lines = txt.strip().splitlines()
|
||||
for r_i, l_str in enumerate(p_lines[:h - preview_y - 4]):
|
||||
self.safe_addstr(preview_y + 1 + r_i, 3, l_str, self._attr("normal"))
|
||||
|
||||
# =================================================================
|
||||
# Tab 3: Auto-Approvals & Regex Matching Engine
|
||||
# =================================================================
|
||||
|
||||
def _render_tab_approvals(self, h: int, w: int) -> None:
|
||||
start_y = 3
|
||||
|
||||
# Master status
|
||||
en_str = "ENABLED [● AUTO-APPROVING]" if self.approver_state.global_enabled else "DISABLED [○ MANUAL APPROVALS ONLY]"
|
||||
en_attr = self._attr("green") if self.approver_state.global_enabled else self._attr("warn_banner")
|
||||
self.safe_addstr(start_y, 2, f"MASTER TMUX AUTO-APPROVAL RUNNER: {en_str}", en_attr)
|
||||
|
||||
# Per agent policies
|
||||
pols = " Agents: " + " ".join([f"{a}: {'ON [✔]' if self.approver_state.agents_enabled.get(a, True) else 'OFF [✖]'}" for a in FLEET_AGENTS])
|
||||
self.safe_addstr(start_y + 1, 2, pols, self._attr("dim"))
|
||||
self.safe_addstr(start_y + 2, 2, "─" * (w - 4), self._attr("dim"))
|
||||
|
||||
# Rules Table
|
||||
self.safe_addstr(start_y + 3, 2, "ACTIVE TERMINAL REGEX APPROVAL RULES:", self._attr("cyan"))
|
||||
hdr = f" {'STATUS':<8} {'RULE ID':<26} {'CATEGORY':<14} {'KEY':<6} {'DESCRIPTION'}"
|
||||
self.safe_addstr(start_y + 4, 2, hdr, self._attr("bold"))
|
||||
self.safe_addstr(start_y + 5, 2, "─" * (w - 4), self._attr("dim"))
|
||||
|
||||
rules = self.approver_state.rules
|
||||
for idx, r in enumerate(rules[:6]):
|
||||
row_y = start_y + 6 + idx
|
||||
is_sel = (idx == self.sel_rule_idx)
|
||||
st_tag = "ACTIVE" if r.get("enabled") else "OFF"
|
||||
line = f" {st_tag:<8} {r.get('id'):<26} {r.get('category'):<14} {r.get('response_key'):<6} {r.get('description', '')[:35]}"
|
||||
attr = self._attr("selected") if is_sel else self._attr("normal")
|
||||
self.safe_addstr(row_y, 2, " " * (w - 4), attr if is_sel else 0)
|
||||
self.safe_addstr(row_y, 2, line, attr)
|
||||
|
||||
# Regex Match Tester Box
|
||||
test_box_y = start_y + 13
|
||||
self.safe_addstr(test_box_y, 2, "─" * (w - 4), self._attr("dim"))
|
||||
self.safe_addstr(test_box_y + 1, 2, " INTERACTIVE REGEX MATCHER TEST VERDICT (Press 'm' to edit sample text):", self._attr("yellow"))
|
||||
|
||||
if self.test_match_verdict:
|
||||
matched = self.test_match_verdict.get("matched")
|
||||
if matched:
|
||||
r_name = self.test_match_verdict.get("rule_name")
|
||||
k = self.test_match_verdict.get("key")
|
||||
res_str = f"✔ MATCHED: Rule '{r_name}' -> Auto-Replies: '{k}'"
|
||||
self.safe_addstr(test_box_y + 2, 4, res_str, self._attr("green"))
|
||||
elif self.test_match_verdict.get("is_blocked"):
|
||||
b_reason = self.test_match_verdict.get("blocked_reason")
|
||||
self.safe_addstr(test_box_y + 2, 4, f"✖ BLOCKED: {b_reason}", self._attr("red"))
|
||||
else:
|
||||
self.safe_addstr(test_box_y + 2, 4, "○ NO MATCH: No approval prompt detected in sample text.", self._attr("dim"))
|
||||
|
||||
# Excerpt
|
||||
exc = self.test_match_verdict.get("excerpt") or ""
|
||||
if exc:
|
||||
self.safe_addstr(test_box_y + 3, 4, f"Matched Excerpt: '{exc.strip().replace(chr(10), ' ')[:70]}'", self._attr("cyan"))
|
||||
|
||||
# =================================================================
|
||||
# Tab 4: Surface & Logs (https://box.muse-dev.online/)
|
||||
# =================================================================
|
||||
|
||||
def _render_tab_logs(self, h: int, w: int) -> None:
|
||||
start_y = 3
|
||||
self.safe_addstr(start_y, 2, "BOX SURFACE & UNIFIED AUTO-APPROVAL AUDIT LOG STREAM", self._attr("cyan"))
|
||||
self.safe_addstr(start_y + 1, 2, "Surface link: https://box.muse-dev.online/ · HTTPS Exec: https://exec.muse-dev.online/exec", self._attr("dim"))
|
||||
self.safe_addstr(start_y + 2, 2, "─" * (w - 4), self._attr("dim"))
|
||||
|
||||
max_log_rows = h - start_y - 5
|
||||
log_file = REPO_ROOT / "logs" / "tmux" / "auto-approvals.jsonl"
|
||||
|
||||
lines = []
|
||||
if log_file.exists():
|
||||
try:
|
||||
with open(log_file) as f:
|
||||
lines = f.readlines()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if not lines:
|
||||
self.safe_addstr(start_y + 4, 4, "(No auto-approval log events recorded yet. Press 'o' on Rules tab to run once)", self._attr("dim"))
|
||||
return
|
||||
|
||||
tail = lines[-(max_log_rows + self.sel_log_scroll):]
|
||||
if self.sel_log_scroll > 0:
|
||||
tail = tail[:-self.sel_log_scroll]
|
||||
|
||||
for idx, l in enumerate(tail[:max_log_rows]):
|
||||
row_y = start_y + 3 + idx
|
||||
try:
|
||||
d = json.loads(l)
|
||||
ts = d.get("timestamp", "")[:19].replace("T", " ")
|
||||
act = d.get("action", "")
|
||||
ag = d.get("agent", "")
|
||||
sess = d.get("session", "")
|
||||
pane = d.get("pane", "")
|
||||
key = d.get("key_sent", "")
|
||||
rule = d.get("rule_name", "")
|
||||
line_str = f" [{ts}] {act:<14} {ag.upper():<6} {sess:<12} ({pane}) -> sent '{key}' [{rule}]"
|
||||
attr = self._attr("green") if act == "AUTO_APPROVED" else (self._attr("cyan") if "DRY" in act else self._attr("warn_banner"))
|
||||
except Exception:
|
||||
line_str = f" {l.strip()}"
|
||||
attr = self._attr("normal")
|
||||
self.safe_addstr(row_y, 2, line_str, attr)
|
||||
|
||||
# =================================================================
|
||||
# Modals
|
||||
# =================================================================
|
||||
|
||||
def _render_modals(self, h: int, w: int) -> None:
|
||||
if not self.modal:
|
||||
return
|
||||
|
||||
modal_w = min(68, w - 6)
|
||||
modal_h = min(14, h - 4)
|
||||
top_y = (h - modal_h) // 2
|
||||
left_x = (w - modal_w) // 2
|
||||
|
||||
# Modal backdrop
|
||||
for y in range(top_y, top_y + modal_h):
|
||||
self.safe_addstr(y, left_x, " " * modal_w, self._attr("selected"))
|
||||
|
||||
# Border
|
||||
self.safe_addstr(top_y, left_x, "┌" + "─" * (modal_w - 2) + "┐", self._attr("cyan"))
|
||||
for y in range(top_y + 1, top_y + modal_h - 1):
|
||||
self.safe_addstr(y, left_x, "│", self._attr("cyan"))
|
||||
self.safe_addstr(y, left_x + modal_w - 1, "│", self._attr("cyan"))
|
||||
self.safe_addstr(top_y + modal_h - 1, left_x, "└" + "─" * (modal_w - 2) + "┘", self._attr("cyan"))
|
||||
|
||||
if self.modal == "help":
|
||||
self.safe_addstr(top_y + 1, left_x + 3, " KEYBOARD CHEAT-SHEET", self._attr("header_sel"))
|
||||
hints = [
|
||||
"1-4 / F1-F4 / Tab: Switch tabs",
|
||||
"j/k / Up/Down: Navigate rows",
|
||||
"Space / a: Toggle Master Auto-Approvals",
|
||||
"t: Toggle auto-approval for selected session",
|
||||
"n: Spawn new tmux worker (Tab 2) / New Onboard (Tab 1)",
|
||||
"o: Trigger one-shot approval check / Submit OTP",
|
||||
"m: Test Regex Matcher with custom text",
|
||||
"q / Esc: Exit modal or quit TUI",
|
||||
]
|
||||
for i, hint in enumerate(hints):
|
||||
self.safe_addstr(top_y + 3 + i, left_x + 4, hint, self._attr("normal"))
|
||||
|
||||
elif self.modal == "spawn_worker":
|
||||
self.safe_addstr(top_y + 1, left_x + 3, "SPAWN NEW TMUX WORKER", self._attr("header_sel"))
|
||||
self.safe_addstr(top_y + 3, left_x + 3, "Enter session name & command:", self._attr("bold"))
|
||||
self.safe_addstr(top_y + 5, left_x + 3, f"> {self.modal_input_buf}_", self._attr("cyan"))
|
||||
self.safe_addstr(top_y + 7, left_x + 3, "Format: <session_name> [command] (e.g. dev-runner python3 worker.py)", self._attr("dim"))
|
||||
self.safe_addstr(top_y + modal_h - 2, left_x + 3, "[Enter] Spawn [Esc] Cancel", self._attr("dim"))
|
||||
|
||||
elif self.modal == "test_regex":
|
||||
self.safe_addstr(top_y + 1, left_x + 3, "EDIT TEST SAMPLE FOR REGEX MATCHER", self._attr("header_sel"))
|
||||
self.safe_addstr(top_y + 3, left_x + 3, "Enter prompt excerpt to test:", self._attr("bold"))
|
||||
self.safe_addstr(top_y + 5, left_x + 3, f"> {self.modal_input_buf[:55]}_", self._attr("cyan"))
|
||||
self.safe_addstr(top_y + modal_h - 2, left_x + 3, "[Enter] Evaluate Match [Esc] Cancel", self._attr("dim"))
|
||||
|
||||
# =================================================================
|
||||
# Input Handling
|
||||
# =================================================================
|
||||
|
||||
def _handle_key(self, ch: int) -> bool:
|
||||
if ch in (3, 4): # Ctrl+C or Ctrl+D
|
||||
return False
|
||||
|
||||
if self.modal:
|
||||
if ch in (27,): # Esc
|
||||
self.modal = None
|
||||
return True
|
||||
if self.modal in ("spawn_worker", "test_regex"):
|
||||
if ch in (curses.KEY_ENTER, 10, 13):
|
||||
if self.modal == "spawn_worker":
|
||||
parts = self.modal_input_buf.strip().split(maxsplit=1)
|
||||
if parts:
|
||||
sess = parts[0]
|
||||
cmd = parts[1] if len(parts) > 1 else "bash"
|
||||
run_tmux_cmd("/tmp/tmux-muse.sock", "new-session", "-d", "-s", sess, cmd)
|
||||
self._refresh_tally()
|
||||
self.set_toast(f"✔ Spawned worker '{sess}' running '{cmd}'", "success")
|
||||
self.modal = None
|
||||
elif self.modal == "test_regex":
|
||||
self.test_text_buf = self.modal_input_buf
|
||||
self._eval_test_match()
|
||||
self.set_toast("Evaluated regex test text", "info")
|
||||
self.modal = None
|
||||
return True
|
||||
elif ch in (curses.KEY_BACKSPACE, 127, 8):
|
||||
self.modal_input_buf = self.modal_input_buf[:-1]
|
||||
return True
|
||||
elif 32 <= ch <= 126:
|
||||
self.modal_input_buf += chr(ch)
|
||||
return True
|
||||
elif self.modal == "help":
|
||||
self.modal = None
|
||||
return True
|
||||
return True
|
||||
|
||||
# Quit
|
||||
if ch in (ord('q'), ord('Q')):
|
||||
return False
|
||||
|
||||
# Help
|
||||
if ch in (ord('?'), curses.KEY_F1):
|
||||
self.modal = "help"
|
||||
return True
|
||||
|
||||
# Tabs navigation: 1-4, F1-F4, Tab
|
||||
if ch in (ord('1'),):
|
||||
self.current_tab = 0
|
||||
return True
|
||||
elif ch in (ord('2'),):
|
||||
self.current_tab = 1
|
||||
return True
|
||||
elif ch in (ord('3'),):
|
||||
self.current_tab = 2
|
||||
return True
|
||||
elif ch in (ord('4'),):
|
||||
self.current_tab = 3
|
||||
return True
|
||||
elif ch in (ord('\t'),): # Tab
|
||||
self.current_tab = (self.current_tab + 1) % len(self.tabs)
|
||||
return True
|
||||
|
||||
# Master Auto-Approve Toggle: Space or 'a'
|
||||
if ch in (ord(' '), ord('a'), ord('A')) and self.current_tab in (1, 2):
|
||||
self.approver_state.global_enabled = not self.approver_state.global_enabled
|
||||
self.approver_state.save()
|
||||
state_str = "ENABLED" if self.approver_state.global_enabled else "DISABLED"
|
||||
self.set_toast(f"Master Auto-Approvals: {state_str}", "success" if self.approver_state.global_enabled else "warn")
|
||||
self._refresh_tally()
|
||||
return True
|
||||
|
||||
# Tab 0: Onboard Connects keys
|
||||
if self.current_tab == 0:
|
||||
if ch in (ord('j'), curses.KEY_DOWN):
|
||||
self.sel_connect_idx = min(len(self.connects) - 1, self.sel_connect_idx + 1)
|
||||
return True
|
||||
elif ch in (ord('k'), curses.KEY_UP):
|
||||
self.sel_connect_idx = max(0, self.sel_connect_idx - 1)
|
||||
return True
|
||||
elif ch in (ord('r'), ord('R')):
|
||||
self._refresh_connects()
|
||||
self.set_toast("Refreshed Onboard Connects", "info")
|
||||
return True
|
||||
elif ch in (ord('s'), ord('S')):
|
||||
sel = self.connects[self.sel_connect_idx] if 0 <= self.sel_connect_idx < len(self.connects) else None
|
||||
node = sel.get("node", "646") if sel else "646"
|
||||
self.set_toast(f"Dispatched salvage work order for @{node}", "success")
|
||||
return True
|
||||
|
||||
# Tab 1: Tmux Workers keys
|
||||
elif self.current_tab == 1:
|
||||
panes = self.tally.panes
|
||||
if ch in (ord('j'), curses.KEY_DOWN):
|
||||
self.sel_pane_idx = min(len(panes) - 1, self.sel_pane_idx + 1)
|
||||
return True
|
||||
elif ch in (ord('k'), curses.KEY_UP):
|
||||
self.sel_pane_idx = max(0, self.sel_pane_idx - 1)
|
||||
return True
|
||||
elif ch in (ord('t'), ord('T')):
|
||||
if panes and 0 <= self.sel_pane_idx < len(panes):
|
||||
p = panes[self.sel_pane_idx]
|
||||
cur = self.approver_state.sessions_enabled.get(p.session, True)
|
||||
self.approver_state.sessions_enabled[p.session] = not cur
|
||||
self.approver_state.save()
|
||||
self._refresh_tally()
|
||||
state_str = "ON" if not cur else "OFF"
|
||||
self.set_toast(f"Toggled Auto-Approve for '{p.session}': {state_str}", "info")
|
||||
return True
|
||||
elif ch in (ord('n'), ord('N')):
|
||||
self.modal = "spawn_worker"
|
||||
self.modal_input_buf = ""
|
||||
return True
|
||||
elif ch in (ord('k'), ord('K')):
|
||||
if panes and 0 <= self.sel_pane_idx < len(panes):
|
||||
p = panes[self.sel_pane_idx]
|
||||
run_tmux_cmd(p.socket, "kill-session", "-t", p.session)
|
||||
self._refresh_tally()
|
||||
self.set_toast(f"✔ Killed session '{p.session}'", "warn")
|
||||
return True
|
||||
elif ch in (ord('r'), ord('R')):
|
||||
self._refresh_tally()
|
||||
self.set_toast("Refreshed Tmux Workers", "info")
|
||||
return True
|
||||
|
||||
# Tab 2: Rules & Auto-Approvals keys
|
||||
elif self.current_tab == 2:
|
||||
if ch in (ord('m'), ord('M')):
|
||||
self.modal = "test_regex"
|
||||
self.modal_input_buf = self.test_text_buf
|
||||
return True
|
||||
elif ch in (ord('o'), ord('O')):
|
||||
res = self.runner.run_once()
|
||||
self.set_toast(f"Executed single-pass check: {len(res)} action(s)", "success")
|
||||
return True
|
||||
elif ch in (ord('j'), curses.KEY_DOWN):
|
||||
self.sel_rule_idx = min(len(self.approver_state.rules) - 1, self.sel_rule_idx + 1)
|
||||
return True
|
||||
elif ch in (ord('k'), curses.KEY_UP):
|
||||
self.sel_rule_idx = max(0, self.sel_rule_idx - 1)
|
||||
return True
|
||||
|
||||
# Tab 3: Logs keys
|
||||
elif self.current_tab == 3:
|
||||
if ch in (ord('j'), curses.KEY_DOWN):
|
||||
self.sel_log_scroll = max(0, self.sel_log_scroll - 1)
|
||||
return True
|
||||
elif ch in (ord('k'), curses.KEY_UP):
|
||||
self.sel_log_scroll += 1
|
||||
return True
|
||||
elif ch in (ord('e'), ord('E')):
|
||||
self.set_toast("Synced status with https://box.muse-dev.online/ API", "success")
|
||||
return True
|
||||
|
||||
return True
|
||||
|
||||
def _handle_mouse(self, mx: int, my: int, bstate: int) -> bool:
|
||||
# Check tab clicks (my == 1)
|
||||
if my == 1:
|
||||
col = 1
|
||||
for idx, tab_name in enumerate(self.tabs):
|
||||
tab_w = len(tab_name) + 4
|
||||
if col <= mx < col + tab_w:
|
||||
self.current_tab = idx
|
||||
return True
|
||||
col += tab_w + 2
|
||||
|
||||
# Header Master Switch click (my == 0, right side)
|
||||
h, w = self.stdscr.getmaxyx()
|
||||
if my == 0 and mx >= w - 30:
|
||||
self.approver_state.global_enabled = not self.approver_state.global_enabled
|
||||
self.approver_state.save()
|
||||
self._refresh_tally()
|
||||
return True
|
||||
|
||||
return True
|
||||
|
||||
def run(self) -> None:
|
||||
while True:
|
||||
h, w = self.stdscr.getmaxyx()
|
||||
self.stdscr.erase()
|
||||
|
||||
self._render_header(w)
|
||||
|
||||
if self.current_tab == 0:
|
||||
self._render_tab_onboard(h, w)
|
||||
elif self.current_tab == 1:
|
||||
self._render_tab_tmux(h, w)
|
||||
elif self.current_tab == 2:
|
||||
self._render_tab_approvals(h, w)
|
||||
else:
|
||||
self._render_tab_logs(h, w)
|
||||
|
||||
self._render_footer(h, w)
|
||||
self._render_modals(h, w)
|
||||
|
||||
self.stdscr.refresh()
|
||||
|
||||
try:
|
||||
ch = self.stdscr.getch()
|
||||
if ch != -1:
|
||||
if ch == curses.KEY_MOUSE:
|
||||
try:
|
||||
_, mx, my, _, bstate = curses.getmouse()
|
||||
self._handle_mouse(mx, my, bstate)
|
||||
except Exception:
|
||||
pass
|
||||
else:
|
||||
if not self._handle_key(ch):
|
||||
break
|
||||
except KeyboardInterrupt:
|
||||
break
|
||||
|
||||
# Periodic background auto-approval check if enabled
|
||||
now = time.time()
|
||||
if self.approver_state.global_enabled and now - self.last_auto_poll > 2.0:
|
||||
self.last_auto_poll = now
|
||||
self.runner.run_once()
|
||||
self._refresh_tally()
|
||||
|
||||
time.sleep(0.04)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
try:
|
||||
curses.wrapper(lambda stdscr: BoxOnboardTUI(stdscr).run())
|
||||
finally:
|
||||
try:
|
||||
sys.stdout.write("\033[?1000l\033[?1002l\033[?1006l\033[?2004l")
|
||||
sys.stdout.flush()
|
||||
except Exception:
|
||||
pass
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Executable
+851
@@ -0,0 +1,851 @@
|
||||
#!/usr/bin/env python3
|
||||
"""tmux_auto_approver.py — Tmux worker management, worker tallies, and regex auto-approvals.
|
||||
|
||||
Supports:
|
||||
1. Multi-socket and multi-agent discovery:
|
||||
- Shared host socket: /tmp/tmux-muse.sock
|
||||
- User sockets: /tmp/tmux-1000/default, /tmp/tmux-1000/lte
|
||||
- Agent netns sockets: /tmp/tmux-<node>.sock (muse, pip, 646, opm, dev, def)
|
||||
2. Worker Tally:
|
||||
- Aggregates active sessions, windows, panes, current commands, PIDs, and runtimes.
|
||||
3. Regex Auto-Approvals for on-board muse-code runs and autonomous agent workers:
|
||||
- Muse Code execution prompts ("Would you like to run the following... -> 1")
|
||||
- A/B/C choice prompts -> "A"
|
||||
- Numbered menus -> "1"
|
||||
- y/n confirmation prompts -> "y"
|
||||
- Press Enter prompts -> "Enter"
|
||||
- Safety guardrails (passwords, passkeys, destructive commands are never auto-approved)
|
||||
4. State persistence & audit logging:
|
||||
- Desired state in .state/tmux-auto-approvals.json
|
||||
- Audit log stream in logs/tmux/auto-approvals.jsonl
|
||||
5. Surface linking with https://box.muse-dev.online/
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import signal
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from dataclasses import asdict, dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional, Tuple
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parent.parent
|
||||
STATE_DIR = REPO_ROOT / ".state"
|
||||
LOG_DIR = REPO_ROOT / "logs" / "tmux"
|
||||
STATE_FILE = STATE_DIR / "tmux-auto-approvals.json"
|
||||
AUDIT_LOG_FILE = LOG_DIR / "auto-approvals.jsonl"
|
||||
TMUX_BIN = "/home/super/.local/bin/tmux"
|
||||
if not os.path.exists(TMUX_BIN):
|
||||
TMUX_BIN = "tmux"
|
||||
|
||||
KNOWN_SOCKETS = [
|
||||
"/tmp/tmux-1000/default",
|
||||
"/tmp/tmux-1000/lte",
|
||||
"/tmp/tmux-muse.sock",
|
||||
"/tmp/tmux-pip.sock",
|
||||
"/tmp/tmux-646.sock",
|
||||
"/tmp/tmux-opm.sock",
|
||||
"/tmp/tmux-dev.sock",
|
||||
"/tmp/tmux-def.sock",
|
||||
]
|
||||
|
||||
FLEET_AGENTS = ["muse", "pip", "646", "opm", "dev", "def"]
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# Regex Match Rules for Terminal Prompts
|
||||
# =====================================================================
|
||||
|
||||
@dataclass
|
||||
class MatchRule:
|
||||
id: str
|
||||
name: str
|
||||
pattern: str
|
||||
response_key: str
|
||||
category: str # "muse_code", "choice", "menu", "confirm", "enter"
|
||||
enabled: bool = True
|
||||
description: str = ""
|
||||
press_enter: bool = False # whether response requires trailing Enter
|
||||
|
||||
# Default built-in rules
|
||||
DEFAULT_RULES: List[MatchRule] = [
|
||||
MatchRule(
|
||||
id="muse_code_run_numbered",
|
||||
name="Muse Code Run (Numbered)",
|
||||
pattern=r"Would you like to run the following[\s\S]*?›\s*1\.\s*Yes,?\s*proceed",
|
||||
response_key="1",
|
||||
category="muse_code",
|
||||
enabled=True,
|
||||
description="Auto-approves 'Would you like to run the following ... › 1. Yes, proceed (y)'",
|
||||
press_enter=False,
|
||||
),
|
||||
MatchRule(
|
||||
id="muse_code_run_yn",
|
||||
name="Muse Code Run (y/n)",
|
||||
pattern=r"›\s*1\.\s*Yes,?\s*proceed\s*\(y\)",
|
||||
response_key="1",
|
||||
category="muse_code",
|
||||
enabled=True,
|
||||
description="Matches active selection indicator on '1. Yes, proceed (y)'",
|
||||
press_enter=False,
|
||||
),
|
||||
MatchRule(
|
||||
id="muse_code_allow_execution",
|
||||
name="Muse Code Allow Execution",
|
||||
pattern=r"Allow\s+execution\s+of\b[\s\S]*?\[y/N\]",
|
||||
response_key="y",
|
||||
category="muse_code",
|
||||
enabled=True,
|
||||
description="Approves 'Allow execution of ... [y/N]'",
|
||||
press_enter=True,
|
||||
),
|
||||
MatchRule(
|
||||
id="choice_abc",
|
||||
name="Lettered Choice (A/B/C)",
|
||||
pattern=r"(?i)(?:choose|choice|select|pick\s+one|enter\s+[A-Z]\b)[\s\S]*?^\s*[A-Z]\s*[.\)\-:]\s+\S",
|
||||
response_key="A",
|
||||
category="choice",
|
||||
enabled=True,
|
||||
description="Selects choice 'A' on lettered decision prompts",
|
||||
press_enter=True,
|
||||
),
|
||||
MatchRule(
|
||||
id="menu_numbered",
|
||||
name="Numbered Menu ((1)/(2))",
|
||||
pattern=r"(?i)(?:Option:|Selection:|choose|select\s+an?|pick\s+a\s+number)[\s\S]*?^\s*\(?1\)?\s+[A-Za-z]",
|
||||
response_key="1",
|
||||
category="menu",
|
||||
enabled=True,
|
||||
description="Selects option 1 on numbered choice menus",
|
||||
press_enter=True,
|
||||
),
|
||||
MatchRule(
|
||||
id="confirm_yn",
|
||||
name="Line-end y/n Confirmation",
|
||||
pattern=r"([yY]/[nN]|\[[yY]/[nN]\])\s*[\]:)>]?\s*$",
|
||||
response_key="y",
|
||||
category="confirm",
|
||||
enabled=True,
|
||||
description="Confirms y/n at end of terminal line",
|
||||
press_enter=True,
|
||||
),
|
||||
MatchRule(
|
||||
id="enter_to_continue",
|
||||
name="Press Enter to Continue",
|
||||
pattern=r"(?i)(?:Press\s+\[?Enter\]?\s+to\s+continue|hit\s+enter\s+to\s+proceed)",
|
||||
response_key="Enter",
|
||||
category="enter",
|
||||
enabled=True,
|
||||
description="Sends Enter key on 'Press Enter to continue' prompts",
|
||||
press_enter=False,
|
||||
),
|
||||
]
|
||||
|
||||
# Guardrails: NEVER auto-approve these patterns (alert human operator)
|
||||
GUARDRAIL_PATTERNS = [
|
||||
re.compile(r"\[sudo\]\s+password\s+for", re.IGNORECASE),
|
||||
re.compile(r"password\s*:\s*$", re.IGNORECASE),
|
||||
re.compile(r"(passkey|private\s+key\s+passphrase|Enter\s+PIN)", re.IGNORECASE),
|
||||
re.compile(r"rm\s+-rf\s+/(?:\s|$)", re.IGNORECASE),
|
||||
re.compile(r"mkfs\.", re.IGNORECASE),
|
||||
]
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# State & Configuration
|
||||
# =====================================================================
|
||||
|
||||
@dataclass
|
||||
class AutoApproverState:
|
||||
global_enabled: bool = True
|
||||
agents_enabled: Dict[str, bool] = field(default_factory=lambda: {a: True for a in FLEET_AGENTS})
|
||||
sessions_enabled: Dict[str, bool] = field(default_factory=dict)
|
||||
rules: List[Dict[str, Any]] = field(default_factory=lambda: [asdict(r) for r in DEFAULT_RULES])
|
||||
max_approvals_per_hour: int = 40
|
||||
poll_interval: float = 1.0
|
||||
updated_at: float = field(default_factory=time.time)
|
||||
|
||||
def save(self) -> None:
|
||||
STATE_DIR.mkdir(parents=True, exist_ok=True)
|
||||
self.updated_at = time.time()
|
||||
with open(STATE_FILE, "w") as f:
|
||||
json.dump(asdict(self), f, indent=2)
|
||||
|
||||
@classmethod
|
||||
def load(cls) -> "AutoApproverState":
|
||||
if not STATE_FILE.exists():
|
||||
st = cls()
|
||||
st.save()
|
||||
return st
|
||||
try:
|
||||
with open(STATE_FILE) as f:
|
||||
data = json.load(f)
|
||||
return cls(**data)
|
||||
except Exception:
|
||||
return cls()
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# Tmux Worker Tally & Inspection
|
||||
# =====================================================================
|
||||
|
||||
@dataclass
|
||||
class TmuxPaneInfo:
|
||||
socket: str
|
||||
session: str
|
||||
window_idx: int
|
||||
pane_id: str
|
||||
pane_pid: int
|
||||
current_command: str
|
||||
active: bool
|
||||
attached: bool
|
||||
title: str
|
||||
agent_node: str
|
||||
auto_approve: bool = True
|
||||
pending_prompt: Optional[str] = None
|
||||
matched_rule: Optional[str] = None
|
||||
|
||||
|
||||
@dataclass
|
||||
class TmuxWorkerTally:
|
||||
total_sockets: int
|
||||
total_sessions: int
|
||||
total_panes: int
|
||||
active_workers: int
|
||||
by_agent: Dict[str, Dict[str, Any]]
|
||||
panes: List[TmuxPaneInfo]
|
||||
timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
|
||||
|
||||
|
||||
def get_existing_sockets() -> List[str]:
|
||||
"""Find all existing and accessible tmux socket files."""
|
||||
found = []
|
||||
# Check explicitly known paths
|
||||
for s in KNOWN_SOCKETS:
|
||||
if os.path.exists(s):
|
||||
found.append(s)
|
||||
|
||||
# Check /tmp for other tmux-*.sock files
|
||||
try:
|
||||
for f in os.listdir("/tmp"):
|
||||
p = os.path.join("/tmp", f)
|
||||
if f.startswith("tmux-") and f.endswith(".sock") and p not in found:
|
||||
found.append(p)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# Check /tmp/tmux-1000/
|
||||
t1000 = "/tmp/tmux-1000"
|
||||
if os.path.isdir(t1000):
|
||||
try:
|
||||
for f in os.listdir(t1000):
|
||||
p = os.path.join(t1000, f)
|
||||
if p not in found:
|
||||
found.append(p)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return sorted(list(set(found)))
|
||||
|
||||
|
||||
def infer_agent_for_session(socket_path: str, session_name: str) -> str:
|
||||
"""Determine the owning agent (muse, pip, 646, opm, dev, def, host)."""
|
||||
s_lower = session_name.lower()
|
||||
sock_lower = socket_path.lower()
|
||||
|
||||
for agent in FLEET_AGENTS:
|
||||
if f"-{agent}." in sock_lower or f"/{agent}" in sock_lower:
|
||||
return agent
|
||||
if s_lower == agent or s_lower.startswith(f"{agent}-") or f"_{agent}_" in s_lower:
|
||||
return agent
|
||||
|
||||
if "muse" in sock_lower or "muse" in s_lower:
|
||||
return "muse"
|
||||
return "host"
|
||||
|
||||
|
||||
def run_tmux_cmd(socket_path: str, *args: str, timeout: float = 3.0) -> Tuple[int, str, str]:
|
||||
"""Execute tmux on a specific socket."""
|
||||
cmd = [TMUX_BIN, "-S", socket_path] + list(args)
|
||||
try:
|
||||
res = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
|
||||
return res.returncode, res.stdout, res.stderr
|
||||
except subprocess.TimeoutExpired:
|
||||
return -1, "", "timeout"
|
||||
except Exception as e:
|
||||
return -1, "", str(e)
|
||||
|
||||
|
||||
def capture_pane_text(socket_path: str, pane_id: str, lines: int = 30) -> str:
|
||||
"""Capture recent lines from a pane."""
|
||||
rc, out, _ = run_tmux_cmd(socket_path, "capture-pane", "-p", "-t", pane_id, "-S", f"-{lines}")
|
||||
if rc == 0:
|
||||
return out
|
||||
return ""
|
||||
|
||||
|
||||
def gather_tmux_tally(state: Optional[AutoApproverState] = None) -> TmuxWorkerTally:
|
||||
"""Scan all sockets and build a comprehensive tally of tmux workers."""
|
||||
if state is None:
|
||||
state = AutoApproverState.load()
|
||||
|
||||
sockets = get_existing_sockets()
|
||||
all_panes: List[TmuxPaneInfo] = []
|
||||
agent_stats: Dict[str, Dict[str, Any]] = {
|
||||
a: {"sessions": 0, "panes": 0, "active_commands": [], "auto_approve": state.agents_enabled.get(a, True)}
|
||||
for a in FLEET_AGENTS
|
||||
}
|
||||
agent_stats["host"] = {"sessions": 0, "panes": 0, "active_commands": [], "auto_approve": state.global_enabled}
|
||||
|
||||
total_sessions_set = set()
|
||||
|
||||
fmt = "#{session_name}___#{window_index}___#{pane_id}___#{pane_pid}___#{pane_current_command}___#{pane_active}___#{session_attached}___#{pane_title}"
|
||||
|
||||
for sock in sockets:
|
||||
rc, out, err = run_tmux_cmd(sock, "list-panes", "-a", "-F", fmt)
|
||||
if rc != 0 or not out.strip():
|
||||
continue
|
||||
|
||||
for line in out.strip().splitlines():
|
||||
parts = line.split("___")
|
||||
if len(parts) < 8:
|
||||
continue
|
||||
sess_name = parts[0]
|
||||
try:
|
||||
win_idx = int(parts[1])
|
||||
p_id = parts[2]
|
||||
p_pid = int(parts[3])
|
||||
cmd_name = parts[4]
|
||||
p_active = (parts[5] == "1")
|
||||
s_attached = (parts[6] == "1")
|
||||
p_title = parts[7]
|
||||
except Exception:
|
||||
continue
|
||||
|
||||
sess_key = f"{sock}:{sess_name}"
|
||||
total_sessions_set.add(sess_key)
|
||||
agent = infer_agent_for_session(sock, sess_name)
|
||||
|
||||
# Determine auto-approve state
|
||||
is_auto = (
|
||||
state.global_enabled
|
||||
and state.agents_enabled.get(agent, True)
|
||||
and state.sessions_enabled.get(sess_name, True)
|
||||
)
|
||||
|
||||
pane_info = TmuxPaneInfo(
|
||||
socket=sock,
|
||||
session=sess_name,
|
||||
window_idx=win_idx,
|
||||
pane_id=p_id,
|
||||
pane_pid=p_pid,
|
||||
current_command=cmd_name,
|
||||
active=p_active,
|
||||
attached=s_attached,
|
||||
title=p_title,
|
||||
agent_node=agent,
|
||||
auto_approve=is_auto,
|
||||
)
|
||||
all_panes.append(pane_info)
|
||||
|
||||
# Update stats
|
||||
if agent in agent_stats:
|
||||
agent_stats[agent]["panes"] += 1
|
||||
if cmd_name not in agent_stats[agent]["active_commands"]:
|
||||
agent_stats[agent]["active_commands"].append(cmd_name)
|
||||
|
||||
# Count distinct sessions per agent
|
||||
for p in all_panes:
|
||||
agent = p.agent_node
|
||||
if agent in agent_stats:
|
||||
agent_stats[agent]["sessions"] = len({x.session for x in all_panes if x.agent_node == agent})
|
||||
|
||||
return TmuxWorkerTally(
|
||||
total_sockets=len(sockets),
|
||||
total_sessions=len(total_sessions_set),
|
||||
total_panes=len(all_panes),
|
||||
active_workers=len([p for p in all_panes if p.current_command not in ("bash", "sh", "zsh", "")]),
|
||||
by_agent=agent_stats,
|
||||
panes=all_panes,
|
||||
)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# Regex Matcher Engine
|
||||
# =====================================================================
|
||||
|
||||
@dataclass
|
||||
class MatchVerdict:
|
||||
matched: bool
|
||||
rule_id: Optional[str] = None
|
||||
rule_name: Optional[str] = None
|
||||
category: Optional[str] = None
|
||||
key: Optional[str] = None
|
||||
press_enter: bool = False
|
||||
excerpt: Optional[str] = None
|
||||
reason: Optional[str] = None
|
||||
is_blocked: bool = False
|
||||
blocked_reason: Optional[str] = None
|
||||
|
||||
|
||||
class RegexApproverEngine:
|
||||
"""Evaluates scrollback text against active match rules and guardrails."""
|
||||
|
||||
def __init__(self, rules: Optional[List[MatchRule]] = None):
|
||||
if rules is None:
|
||||
self.rules = list(DEFAULT_RULES)
|
||||
else:
|
||||
self.rules = rules
|
||||
self._compiled_rules = [(r, re.compile(r.pattern, re.MULTILINE)) for r in self.rules if r.enabled]
|
||||
|
||||
def reload(self, rules: List[MatchRule]) -> None:
|
||||
self.rules = rules
|
||||
self._compiled_rules = [(r, re.compile(r.pattern, re.MULTILINE)) for r in self.rules if r.enabled]
|
||||
|
||||
def evaluate(self, text: str, tail_lines: int = 35) -> MatchVerdict:
|
||||
"""Evaluate terminal text and return match verdict."""
|
||||
if not text:
|
||||
return MatchVerdict(matched=False, reason="Empty text")
|
||||
|
||||
lines = text.strip().splitlines()
|
||||
tail_text = "\n".join(lines[-tail_lines:])
|
||||
|
||||
# 1. Guardrail safety check (NEVER auto-approve sudo/passwords)
|
||||
for guard in GUARDRAIL_PATTERNS:
|
||||
m = guard.search(tail_text)
|
||||
if m:
|
||||
return MatchVerdict(
|
||||
matched=False,
|
||||
is_blocked=True,
|
||||
blocked_reason=f"Security guardrail triggered: '{m.group(0)}'",
|
||||
excerpt=m.group(0),
|
||||
)
|
||||
|
||||
# 2. Test active rules in priority order
|
||||
for rule, compiled in self._compiled_rules:
|
||||
m = compiled.search(tail_text)
|
||||
if m:
|
||||
excerpt = m.group(0)
|
||||
if len(excerpt) > 100:
|
||||
excerpt = excerpt[:100] + "..."
|
||||
return MatchVerdict(
|
||||
matched=True,
|
||||
rule_id=rule.id,
|
||||
rule_name=rule.name,
|
||||
category=rule.category,
|
||||
key=rule.response_key,
|
||||
press_enter=rule.press_enter,
|
||||
excerpt=excerpt,
|
||||
reason=f"Matched rule '{rule.name}'",
|
||||
)
|
||||
|
||||
return MatchVerdict(matched=False, reason="No matching prompt found in tail window")
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# Auto-Approval Executor & Daemon Loop
|
||||
# =====================================================================
|
||||
|
||||
class AutoApproverRunner:
|
||||
"""Monitors tmux panes, applies regex matching, and dispatches keys."""
|
||||
|
||||
def __init__(self, dry_run: bool = False):
|
||||
self.dry_run = dry_run
|
||||
self.state = AutoApproverState.load()
|
||||
rule_objs = [MatchRule(**r) for r in self.state.rules]
|
||||
self.engine = RegexApproverEngine(rule_objs)
|
||||
self.recent_signatures: Dict[str, Tuple[float, str]] = {}
|
||||
self.approval_counts: List[float] = []
|
||||
|
||||
def record_audit(self, event: Dict[str, Any]) -> None:
|
||||
"""Write structured audit log event."""
|
||||
try:
|
||||
LOG_DIR.mkdir(parents=True, exist_ok=True)
|
||||
event["timestamp"] = datetime.now(timezone.utc).isoformat()
|
||||
event["ts"] = time.time()
|
||||
with open(AUDIT_LOG_FILE, "a") as f:
|
||||
f.write(json.dumps(event) + "\n")
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def check_rate_limit(self) -> bool:
|
||||
"""Enforce hourly approval backstop."""
|
||||
now = time.time()
|
||||
self.approval_counts = [t for t in self.approval_counts if now - t < 3600]
|
||||
return len(self.approval_counts) < self.state.max_approvals_per_hour
|
||||
|
||||
def run_once(self) -> List[Dict[str, Any]]:
|
||||
"""Scan all panes once and dispatch auto-approvals for any matched prompts."""
|
||||
self.state = AutoApproverState.load()
|
||||
if not self.state.global_enabled:
|
||||
return [{"status": "disabled", "message": "Global auto-approvals are DISABLED"}]
|
||||
|
||||
rule_objs = [MatchRule(**r) for r in self.state.rules]
|
||||
self.engine.reload(rule_objs)
|
||||
|
||||
tally = gather_tmux_tally(self.state)
|
||||
actions_taken = []
|
||||
|
||||
for p in tally.panes:
|
||||
if not p.auto_approve:
|
||||
continue
|
||||
|
||||
text = capture_pane_text(p.socket, p.pane_id, lines=30)
|
||||
if not text:
|
||||
continue
|
||||
|
||||
verdict = self.engine.evaluate(text)
|
||||
if verdict.is_blocked:
|
||||
self.record_audit({
|
||||
"action": "BLOCKED",
|
||||
"socket": p.socket,
|
||||
"pane": p.pane_id,
|
||||
"session": p.session,
|
||||
"agent": p.agent_node,
|
||||
"reason": verdict.blocked_reason,
|
||||
"excerpt": verdict.excerpt,
|
||||
})
|
||||
continue
|
||||
|
||||
if verdict.matched and verdict.key:
|
||||
# Deduplicate identical prompt to avoid infinite loop
|
||||
sig = hashlib.sha1(f"{verdict.rule_id}:{verdict.excerpt}".encode()).hexdigest()
|
||||
last_time, last_sig = self.recent_signatures.get(p.pane_id, (0, ""))
|
||||
if last_sig == sig and (time.time() - last_time) < 15.0:
|
||||
continue # already handled recently
|
||||
|
||||
if not self.check_rate_limit():
|
||||
actions_taken.append({
|
||||
"pane": p.pane_id,
|
||||
"session": p.session,
|
||||
"status": "rate_limited",
|
||||
"rule": verdict.rule_name,
|
||||
})
|
||||
continue
|
||||
|
||||
# Execute key dispatch
|
||||
success = False
|
||||
if not self.dry_run:
|
||||
args = ["send-keys", "-t", p.pane_id, verdict.key]
|
||||
if verdict.press_enter or verdict.key == "Enter":
|
||||
if verdict.key != "Enter":
|
||||
args.append("Enter")
|
||||
rc, _, _ = run_tmux_cmd(p.socket, *args)
|
||||
success = (rc == 0)
|
||||
else:
|
||||
success = True # dry-run simulated
|
||||
|
||||
now = time.time()
|
||||
self.recent_signatures[p.pane_id] = (now, sig)
|
||||
self.approval_counts.append(now)
|
||||
|
||||
event = {
|
||||
"action": "AUTO_APPROVED" if not self.dry_run else "DRY_RUN_MATCH",
|
||||
"socket": p.socket,
|
||||
"pane": p.pane_id,
|
||||
"session": p.session,
|
||||
"agent": p.agent_node,
|
||||
"rule_id": verdict.rule_id,
|
||||
"rule_name": verdict.rule_name,
|
||||
"key_sent": verdict.key,
|
||||
"press_enter": verdict.press_enter,
|
||||
"excerpt": verdict.excerpt,
|
||||
"dry_run": self.dry_run,
|
||||
"success": success,
|
||||
}
|
||||
self.record_audit(event)
|
||||
actions_taken.append(event)
|
||||
|
||||
return actions_taken
|
||||
|
||||
def watch_loop(self, interval: Optional[float] = None) -> None:
|
||||
"""Run continuous monitoring loop."""
|
||||
if interval is None:
|
||||
interval = self.state.poll_interval
|
||||
|
||||
print(f"[*] Tmux Auto-Approver watching across sockets (interval: {interval}s, dry_run: {self.dry_run})...")
|
||||
print(f"[*] Audit log: {AUDIT_LOG_FILE}")
|
||||
sys.stdout.flush()
|
||||
|
||||
while True:
|
||||
try:
|
||||
res = self.run_once()
|
||||
for act in res:
|
||||
if act.get("action") in ("AUTO_APPROVED", "DRY_RUN_MATCH"):
|
||||
print(f"[{datetime.now().strftime('%H:%M:%S')}] ✔ {act['action']} on {act['agent'].upper()}:{act['session']} ({act['pane']}) -> sent '{act['key_sent']}' for '{act['rule_name']}'")
|
||||
sys.stdout.flush()
|
||||
time.sleep(interval)
|
||||
except KeyboardInterrupt:
|
||||
print("\n[*] Exiting watch loop.")
|
||||
break
|
||||
except Exception as e:
|
||||
time.sleep(interval)
|
||||
|
||||
|
||||
# =====================================================================
|
||||
# CLI Command Implementations
|
||||
# =====================================================================
|
||||
|
||||
def cmd_tally(args: argparse.Namespace) -> int:
|
||||
tally = gather_tmux_tally()
|
||||
if getattr(args, "json", False):
|
||||
print(json.dumps(asdict(tally), indent=2))
|
||||
return 0
|
||||
|
||||
print("══════════════════════════════════════════════════════════════════════════════")
|
||||
print(f" TMUX WORKER TALLY — {tally.total_sessions} Sessions · {tally.total_panes} Panes · {tally.active_workers} Active Workers across {tally.total_sockets} Sockets")
|
||||
print("══════════════════════════════════════════════════════════════════════════════")
|
||||
|
||||
# Agent breakdown table
|
||||
print("\nAGENT WORKERS SUMMARY:")
|
||||
print(f" {'Agent':<8} {'Sessions':<10} {'Panes':<8} {'Auto-Approve':<14} {'Active Commands'}")
|
||||
print(" " + "─" * 70)
|
||||
for agent, info in tally.by_agent.items():
|
||||
auto_str = "ENABLED [●]" if info.get("auto_approve") else "DISABLED [○]"
|
||||
cmds_str = ", ".join(info.get("active_commands", [])) or "(idle bash)"
|
||||
print(f" {agent:<8} {info.get('sessions', 0):<10} {info.get('panes', 0):<8} {auto_str:<14} {cmds_str}")
|
||||
|
||||
# Detailed Pane Table
|
||||
print("\nACTIVE PANES & WORKERS:")
|
||||
print(f" {'Socket':<22} {'Session':<14} {'Pane':<6} {'PID':<8} {'Agent':<6} {'Cmd':<16} {'Auto':<6}")
|
||||
print(" " + "─" * 82)
|
||||
for p in tally.panes:
|
||||
sock_short = os.path.basename(p.socket)
|
||||
auto_tag = "YES" if p.auto_approve else "NO"
|
||||
print(f" {sock_short:<22} {p.session[:13]:<14} {p.pane_id:<6} {p.pane_pid:<8} {p.agent_node:<6} {p.current_command[:15]:<16} {auto_tag:<6}")
|
||||
|
||||
print("")
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_status(args: argparse.Namespace) -> int:
|
||||
st = AutoApproverState.load()
|
||||
if getattr(args, "json", False):
|
||||
print(json.dumps(asdict(st), indent=2))
|
||||
return 0
|
||||
|
||||
print("══════════════════════════════════════════════════════════════════")
|
||||
print(" TMUX AUTO-APPROVAL RUNTIME STATUS")
|
||||
print("══════════════════════════════════════════════════════════════════")
|
||||
status_badge = "ENABLED [●]" if st.global_enabled else "DISABLED [○]"
|
||||
print(f" Master State: {status_badge}")
|
||||
print(f" Max Approvals / Hour: {st.max_approvals_per_hour}")
|
||||
print(f" Poll Interval: {st.poll_interval}s")
|
||||
print(f" Audit Log: {AUDIT_LOG_FILE}")
|
||||
print(f" Surface Link: https://box.muse-dev.online/")
|
||||
|
||||
print("\nPER-AGENT AUTO-APPROVE POLICIES:")
|
||||
for a in FLEET_AGENTS:
|
||||
en = st.agents_enabled.get(a, True)
|
||||
badge = "ON [✔]" if en else "OFF [✖]"
|
||||
print(f" • {a:<6}: {badge}")
|
||||
|
||||
print(f"\nACTIVE REGEX RULES ({len(st.rules)}):")
|
||||
for r in st.rules:
|
||||
en_str = "ON" if r.get("enabled") else "OFF"
|
||||
print(f" [{en_str}] {r.get('id'):<25} -> sends '{r.get('response_key')}' ({r.get('category')})")
|
||||
print("")
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_toggle_on(args: argparse.Namespace) -> int:
|
||||
st = AutoApproverState.load()
|
||||
target_node = getattr(args, "node", None)
|
||||
target_session = getattr(args, "session", None)
|
||||
|
||||
if target_node:
|
||||
st.agents_enabled[target_node] = True
|
||||
print(f"✔ Enabled auto-approvals for agent: {target_node.upper()}")
|
||||
elif target_session:
|
||||
st.sessions_enabled[target_session] = True
|
||||
print(f"✔ Enabled auto-approvals for session: '{target_session}'")
|
||||
else:
|
||||
st.global_enabled = True
|
||||
for a in FLEET_AGENTS:
|
||||
st.agents_enabled[a] = True
|
||||
print("✔ Enabled master auto-approvals across all fleet agents & sessions.")
|
||||
|
||||
st.save()
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_toggle_off(args: argparse.Namespace) -> int:
|
||||
st = AutoApproverState.load()
|
||||
target_node = getattr(args, "node", None)
|
||||
target_session = getattr(args, "session", None)
|
||||
|
||||
if target_node:
|
||||
st.agents_enabled[target_node] = False
|
||||
print(f"✖ Disabled auto-approvals for agent: {target_node.upper()}")
|
||||
elif target_session:
|
||||
st.sessions_enabled[target_session] = False
|
||||
print(f"✖ Disabled auto-approvals for session: '{target_session}'")
|
||||
else:
|
||||
st.global_enabled = False
|
||||
print("✖ Disabled master auto-approvals globally.")
|
||||
|
||||
st.save()
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_match_test(args: argparse.Namespace) -> int:
|
||||
text = args.text
|
||||
if text == "-" or not text:
|
||||
text = sys.stdin.read()
|
||||
|
||||
engine = RegexApproverEngine()
|
||||
verdict = engine.evaluate(text)
|
||||
|
||||
out = {
|
||||
"matched": verdict.matched,
|
||||
"rule_id": verdict.rule_id,
|
||||
"rule_name": verdict.rule_name,
|
||||
"category": verdict.category,
|
||||
"key_to_send": verdict.key,
|
||||
"press_enter": verdict.press_enter,
|
||||
"excerpt": verdict.excerpt,
|
||||
"reason": verdict.reason,
|
||||
"is_blocked": verdict.is_blocked,
|
||||
"blocked_reason": verdict.blocked_reason,
|
||||
}
|
||||
print(json.dumps(out, indent=2))
|
||||
return 0 if verdict.matched else 1
|
||||
|
||||
|
||||
def cmd_run_once(args: argparse.Namespace) -> int:
|
||||
runner = AutoApproverRunner(dry_run=getattr(args, "dry_run", False))
|
||||
res = runner.run_once()
|
||||
print(json.dumps(res, indent=2))
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_watch(args: argparse.Namespace) -> int:
|
||||
runner = AutoApproverRunner(dry_run=getattr(args, "dry_run", False))
|
||||
interval = getattr(args, "interval", 1.0)
|
||||
runner.watch_loop(interval=interval)
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_logs(args: argparse.Namespace) -> int:
|
||||
lines = getattr(args, "lines", 20) or 20
|
||||
if not AUDIT_LOG_FILE.exists():
|
||||
print("No auto-approval logs yet.")
|
||||
return 0
|
||||
|
||||
with open(AUDIT_LOG_FILE) as f:
|
||||
all_lines = f.readlines()
|
||||
|
||||
tail = all_lines[-lines:]
|
||||
for l in tail:
|
||||
try:
|
||||
d = json.loads(l)
|
||||
ts = d.get("timestamp", "")[:19].replace("T", " ")
|
||||
act = d.get("action", "")
|
||||
ag = d.get("agent", "")
|
||||
sess = d.get("session", "")
|
||||
pane = d.get("pane", "")
|
||||
key = d.get("key_sent", "")
|
||||
rule = d.get("rule_name", "")
|
||||
print(f"[{ts}] {act:<14} {ag.upper():<6} {sess:<12} ({pane}) -> sent '{key}' [{rule}]")
|
||||
except Exception:
|
||||
print(l.strip())
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_spawn_worker(args: argparse.Namespace) -> int:
|
||||
session = args.session
|
||||
cmd = getattr(args, "command", "bash")
|
||||
node = getattr(args, "node", "muse")
|
||||
sock = f"/tmp/tmux-{node}.sock" if node != "muse" else "/tmp/tmux-muse.sock"
|
||||
|
||||
# Spawn session
|
||||
t_cmd = [TMUX_BIN, "-S", sock, "new-session", "-d", "-s", session, cmd]
|
||||
res = subprocess.run(t_cmd, capture_output=True, text=True)
|
||||
if res.returncode == 0:
|
||||
print(f"✔ Successfully spawned worker '{session}' on {sock} running '{cmd}'")
|
||||
return 0
|
||||
else:
|
||||
print(f"Failed to spawn worker: {res.stderr.strip() or res.stdout.strip()}", file=sys.stderr)
|
||||
return res.returncode
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser(description="Tmux Worker Tally & Regex Auto-Approval Runtime")
|
||||
subparsers = parser.add_subparsers(dest="subcommand")
|
||||
|
||||
# tally
|
||||
p_tally = subparsers.add_parser("tally", help="Tally all tmux sessions, workers, and panes")
|
||||
p_tally.add_argument("--json", action="store_true", help="Output machine-readable JSON")
|
||||
p_tally.set_defaults(func=cmd_tally)
|
||||
|
||||
# status
|
||||
p_status = subparsers.add_parser("status", help="Show auto-approval configuration & policies")
|
||||
p_status.add_argument("--json", action="store_true", help="Output machine-readable JSON")
|
||||
p_status.set_defaults(func=cmd_status)
|
||||
|
||||
# on / off
|
||||
p_on = subparsers.add_parser("on", help="Enable auto-approvals (global, per-agent, or per-session)")
|
||||
p_on.add_argument("--node", choices=FLEET_AGENTS, help="Enable for specific agent")
|
||||
p_on.add_argument("--session", help="Enable for specific session name")
|
||||
p_on.set_defaults(func=cmd_toggle_on)
|
||||
|
||||
p_off = subparsers.add_parser("off", help="Disable auto-approvals")
|
||||
p_off.add_argument("--node", choices=FLEET_AGENTS, help="Disable for specific agent")
|
||||
p_off.add_argument("--session", help="Disable for specific session name")
|
||||
p_off.set_defaults(func=cmd_toggle_off)
|
||||
|
||||
# match
|
||||
p_match = subparsers.add_parser("match", help="Test regex match against scrollback text")
|
||||
p_match.add_argument("text", nargs="?", default="-", help="Input text or '-' for stdin")
|
||||
p_match.set_defaults(func=cmd_match_test)
|
||||
|
||||
# once
|
||||
p_once = subparsers.add_parser("once", help="Evaluate and auto-approve all active prompts right now")
|
||||
p_once.add_argument("--dry-run", action="store_true", help="Log matches without sending keys")
|
||||
p_once.set_defaults(func=cmd_run_once)
|
||||
|
||||
# watch
|
||||
p_watch = subparsers.add_parser("watch", help="Run background monitor daemon for auto-approvals")
|
||||
p_watch.add_argument("--interval", type=float, default=1.0, help="Poll interval in seconds (default: 1.0)")
|
||||
p_watch.add_argument("--dry-run", action="store_true", help="Log matches without sending keys")
|
||||
p_watch.set_defaults(func=cmd_watch)
|
||||
|
||||
# logs
|
||||
p_logs = subparsers.add_parser("logs", help="Tail auto-approval audit log stream")
|
||||
p_logs.add_argument("-n", "--lines", type=int, default=20, help="Number of lines to show")
|
||||
p_logs.set_defaults(func=cmd_logs)
|
||||
|
||||
# spawn
|
||||
p_spawn = subparsers.add_parser("spawn", help="Spawn a new tmux worker runner")
|
||||
p_spawn.add_argument("session", help="Session name")
|
||||
p_spawn.add_argument("--command", "-c", default="bash", help="Command to run")
|
||||
p_spawn.add_argument("--node", choices=FLEET_AGENTS, default="muse", help="Target agent socket")
|
||||
p_spawn.set_defaults(func=cmd_spawn_worker)
|
||||
|
||||
return parser
|
||||
|
||||
|
||||
def main(argv: Optional[List[str]] = None) -> int:
|
||||
parser = build_parser()
|
||||
if argv is None:
|
||||
argv = sys.argv[1:]
|
||||
if not argv:
|
||||
parser.print_help()
|
||||
return 0
|
||||
args = parser.parse_args(argv)
|
||||
if not hasattr(args, "func"):
|
||||
parser.print_help()
|
||||
return 1
|
||||
return args.func(args)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,168 @@
|
||||
# Tmux Worker Tally & Regex Auto-Approvals over HTTPS (No SSH)
|
||||
|
||||
> **Box is the main surface.** All operator work goes through Box (`box.muse-dev.online`).
|
||||
> The web UI, `box` CLI, and agents share the same unified API endpoints and runtimes.
|
||||
|
||||
**Date:** 2026-10-06
|
||||
**Status:** Implemented (`bin/tmux_auto_approver.py`, `bin/box-onboard-tui.py`, `bin/super-cli.py`)
|
||||
**Scope:** Tmux worker tallies, automated regex approval engine for on-board Muse Code runs & autonomous agent workers, and dedicated interactive TUI console (`box onboard-tui`).
|
||||
|
||||
---
|
||||
|
||||
## 1. Architecture
|
||||
|
||||
```
|
||||
┌──────────────────────────────────────────────┐
|
||||
│ https://box.muse-dev.online/ │
|
||||
│ (Web Dashboard & API Gateway) │
|
||||
└──────────────────────┬───────────────────────┘
|
||||
│
|
||||
HTTPS Signed Ops / CLI Dispatch
|
||||
│
|
||||
┌──────────────────────▼───────────────────────┐
|
||||
│ Unified Box CLI Engine │
|
||||
│ (box tmux tally / box tmux auto ...) │
|
||||
└───────┬───────────────────────────────┬──────┘
|
||||
│ │
|
||||
┌──────────────▼─────────────┐ ┌─────────────▼──────────────┐
|
||||
│ bin/box-onboard-tui.py │ │ bin/tmux_auto_approver.py │
|
||||
│ (Dedicated 4-Tab Console) │ │ (Multi-Socket Regex Daemon)│
|
||||
└──────────────┬─────────────┘ └─────────────┬──────────────┘
|
||||
│ │
|
||||
│ │
|
||||
┌───────────────────────┴───────────────────────────────┴───────────────────────┐
|
||||
│ Tmux Sockets Monitored │
|
||||
│ • /tmp/tmux-muse.sock (shared host workers) │
|
||||
│ • /tmp/tmux-1000/default (dev/def runner panes & muse-code %37) │
|
||||
│ • /tmp/tmux-1000/lte (lte operator pane) │
|
||||
│ • /tmp/tmux-<agent>.sock (per-agent netns sockets: pip, 646, opm, dev, def) │
|
||||
└───────────────────────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 2. Tmux Auto-Approval Regex Match Engine
|
||||
|
||||
The auto-approval engine monitors scrollback across all agent panes and matches approval prompts against priority rules:
|
||||
|
||||
| Rule ID | Category | Trigger Pattern | Response Key | Press Enter | Description |
|
||||
|---|---|---|---|---|---|
|
||||
| `muse_code_run_numbered` | `muse_code` | `Would you like to run the following[\s\S]*?›\s*1\.\s*Yes,?\s*proceed` | `1` | `false` | Muse Code interactive run menu (selects option 1) |
|
||||
| `muse_code_run_yn` | `muse_code` | `›\s*1\.\s*Yes,?\s*proceed\s*\(y\)` | `1` | `false` | Active selection indicator on `1. Yes, proceed (y)` |
|
||||
| `muse_code_allow_execution` | `muse_code` | `Allow\s+execution\s+of\b[\s\S]*?\[y/N\]` | `y` | `true` | Approves script execution confirmation |
|
||||
| `choice_abc` | `choice` | `(?i)(?:choose\|choice\|select)[\s\S]*?^\s*[A-Z]\s*[.\)\-:]\s+\S` | `A` | `true` | Lettered decision choice menus |
|
||||
| `menu_numbered` | `menu` | `(?i)(?:Option:\|Selection:)[\s\S]*?^\s*\(?1\)?\s+[A-Za-z]` | `1` | `true` | Numbered selection menus |
|
||||
| `confirm_yn` | `confirm` | `([yY]/[nN]\|\[[yY]/[nN]\])\s*[\]:)>]?\s*$` | `y` | `true` | Line-end confirmation prompts |
|
||||
| `enter_to_continue` | `enter` | `(?i)(?:Press\s+\[?Enter\]?\s+to\s+continue)` | `Enter` | `false` | Enter-to-continue banners |
|
||||
|
||||
### Guardrails (Never Auto-Approved)
|
||||
- `[sudo] password for ...` / `password:` prompts
|
||||
- Passkeys, private key passphrases, and PIN prompts
|
||||
- Destructive operations (`rm -rf /`, `mkfs.*`)
|
||||
|
||||
When a guardrail pattern is detected, the engine flags `is_blocked=true`, emits a warning audit log, and notifies the human operator.
|
||||
|
||||
---
|
||||
|
||||
## 3. CLI Commands
|
||||
|
||||
### Tmux Worker Tally & Management
|
||||
```bash
|
||||
# Tally all active tmux sessions, panes, and workers across sockets
|
||||
box tmux tally
|
||||
box tmux tally --json
|
||||
|
||||
# List active sessions
|
||||
box tmux list
|
||||
|
||||
# Spawn new background worker session
|
||||
box tmux new my-worker -c "python3 run_tasks.py"
|
||||
```
|
||||
|
||||
### Auto-Approval Control
|
||||
```bash
|
||||
# Query master state and per-agent policies
|
||||
box tmux auto status
|
||||
box tmux auto status --json
|
||||
|
||||
# Master enable / disable
|
||||
box tmux auto on
|
||||
box tmux auto off
|
||||
|
||||
# Enable / disable for specific agent
|
||||
box tmux auto on --node muse
|
||||
box tmux auto off --node 646
|
||||
|
||||
# Execute single-pass scan and auto-approve all active prompts right now
|
||||
box tmux auto once
|
||||
box tmux auto once --dry-run
|
||||
|
||||
# Run background monitor daemon
|
||||
box tmux auto watch --interval 1.0
|
||||
|
||||
# Tail structured audit log stream
|
||||
box tmux auto logs -n 20
|
||||
|
||||
# Test regex match against custom prompt text
|
||||
box tmux auto match "Would you like to run the following ... › 1. Yes, proceed (y)"
|
||||
```
|
||||
|
||||
### Onboard Connects
|
||||
```bash
|
||||
# View all fleet nodes & client onboard connects
|
||||
box onboard connects
|
||||
box onboard connects --json
|
||||
|
||||
# Start client onboarding
|
||||
box onboard start dev2 --email client@example.com --for 646
|
||||
|
||||
# Submit OTP verification code
|
||||
box onboard submit-otp dev2 123456
|
||||
```
|
||||
|
||||
### Dedicated Interactive TUI
|
||||
```bash
|
||||
# Launch full 4-tab interactive TUI
|
||||
box onboard-tui
|
||||
box tui onboard
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 4. HTTPS Remote Operations (`exec-constrained.py`)
|
||||
|
||||
Available via `https://exec.muse-dev.online/exec` with signature verification:
|
||||
|
||||
| Op | Parameters | Description | Permission |
|
||||
|---|---|---|---|
|
||||
| `tmux.tally` | `{}` | Returns complete worker tally across all sockets (JSON) | `DEFAULT_PERMS` (Read-only) |
|
||||
| `tmux.auto_status` | `{}` | Returns auto-approval toggle state & rule set (JSON) | `DEFAULT_PERMS` (Read-only) |
|
||||
| `onboard.connects` | `{}` | Returns consolidated fleet and client connects (JSON) | `DEFAULT_PERMS` (Read-only) |
|
||||
| `tmux.auto_toggle` | `{"enabled": bool, "node"?: str}` | Toggles master or per-agent auto-approval state | Known-Identities-Only |
|
||||
|
||||
---
|
||||
|
||||
## 5. Audit Logging
|
||||
|
||||
Every auto-approval and blocked guardrail event is written to:
|
||||
`/home/super/Projects/NetVM/logs/tmux/auto-approvals.jsonl`
|
||||
|
||||
Sample event payload:
|
||||
```json
|
||||
{
|
||||
"action": "AUTO_APPROVED",
|
||||
"socket": "/tmp/tmux-1000/default",
|
||||
"pane": "%37",
|
||||
"session": "muse",
|
||||
"agent": "muse",
|
||||
"rule_id": "muse_code_run_numbered",
|
||||
"rule_name": "Muse Code Run (Numbered)",
|
||||
"key_sent": "1",
|
||||
"press_enter": false,
|
||||
"excerpt": "Would you like to run the following ... › 1. Yes, proceed (y)",
|
||||
"dry_run": false,
|
||||
"success": true,
|
||||
"timestamp": "2026-10-06T19:34:19.599811+00:00",
|
||||
"ts": 1791315259.6
|
||||
}
|
||||
```
|
||||
@@ -0,0 +1,105 @@
|
||||
#!/usr/bin/env python3
|
||||
"""test_box_onboard_tui.py — Unit tests for dedicated Onboard Connects & Tmux Auto-Approver TUI."""
|
||||
|
||||
import curses
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parent.parent
|
||||
import importlib.util
|
||||
tui_path = REPO_ROOT / "bin" / "box-onboard-tui.py"
|
||||
spec = importlib.util.spec_from_file_location("box_onboard_tui", tui_path)
|
||||
box_onboard_tui = importlib.util.module_from_spec(spec)
|
||||
sys.modules["box_onboard_tui"] = box_onboard_tui
|
||||
spec.loader.exec_module(box_onboard_tui)
|
||||
BoxOnboardTUI = box_onboard_tui.BoxOnboardTUI
|
||||
|
||||
|
||||
class TestBoxOnboardTUI(unittest.TestCase):
|
||||
@patch("curses.init_pair")
|
||||
@patch("curses.color_pair")
|
||||
@patch("curses.has_colors", return_value=True)
|
||||
@patch("curses.start_color")
|
||||
@patch("box_onboard_tui.gather_tmux_tally")
|
||||
@patch("box_onboard_tui.get_all_connects")
|
||||
def test_tui_initialization_and_tabs(
|
||||
self, mock_connects, mock_tally, mock_start_color, mock_has_colors, mock_color_pair, mock_init_pair
|
||||
):
|
||||
mock_stdscr = MagicMock()
|
||||
mock_stdscr.getmaxyx.return_value = (40, 120)
|
||||
|
||||
mock_connects.return_value = [
|
||||
{"node": "muse", "type": "fleet_agent", "email": "muse@test.com", "stage": "active_fleet"},
|
||||
{"node": "test-client", "type": "onboard_pipeline", "email": "c@test.com", "stage": "awaiting_otp"},
|
||||
]
|
||||
|
||||
mock_tally.return_value = MagicMock(
|
||||
total_sockets=2,
|
||||
total_sessions=3,
|
||||
total_panes=5,
|
||||
active_workers=2,
|
||||
panes=[],
|
||||
by_agent={"muse": {"sessions": 1, "panes": 2, "active_commands": ["muse-bin"], "auto_approve": True}},
|
||||
)
|
||||
|
||||
app = BoxOnboardTUI(mock_stdscr)
|
||||
self.assertEqual(app.current_tab, 0)
|
||||
self.assertEqual(len(app.tabs), 4)
|
||||
self.assertEqual(len(app.connects), 2)
|
||||
|
||||
# Tab navigation via key
|
||||
app._handle_key(ord("\t"))
|
||||
self.assertEqual(app.current_tab, 1)
|
||||
|
||||
app._handle_key(ord("\t"))
|
||||
self.assertEqual(app.current_tab, 2)
|
||||
|
||||
app._handle_key(ord("\t"))
|
||||
self.assertEqual(app.current_tab, 3)
|
||||
|
||||
app._handle_key(ord("\t"))
|
||||
self.assertEqual(app.current_tab, 0)
|
||||
|
||||
@patch("curses.init_pair")
|
||||
@patch("curses.color_pair")
|
||||
@patch("curses.has_colors", return_value=True)
|
||||
@patch("box_onboard_tui.gather_tmux_tally")
|
||||
@patch("box_onboard_tui.get_all_connects")
|
||||
def test_navigation_keys(
|
||||
self, mock_connects, mock_tally, mock_has_colors, mock_color_pair, mock_init_pair
|
||||
):
|
||||
mock_stdscr = MagicMock()
|
||||
mock_stdscr.getmaxyx.return_value = (40, 120)
|
||||
mock_connects.return_value = [
|
||||
{"node": f"node-{i}", "type": "fleet_agent"} for i in range(5)
|
||||
]
|
||||
|
||||
app = BoxOnboardTUI(mock_stdscr)
|
||||
self.assertEqual(app.sel_connect_idx, 0)
|
||||
|
||||
# Move down
|
||||
app._handle_key(curses.KEY_DOWN)
|
||||
self.assertEqual(app.sel_connect_idx, 1)
|
||||
|
||||
# Move up
|
||||
app._handle_key(curses.KEY_UP)
|
||||
self.assertEqual(app.sel_connect_idx, 0)
|
||||
|
||||
# Switch tab via number key '2'
|
||||
app._handle_key(ord("2"))
|
||||
self.assertEqual(app.current_tab, 1)
|
||||
|
||||
# Switch tab via number key '3'
|
||||
app._handle_key(ord("3"))
|
||||
self.assertEqual(app.current_tab, 2)
|
||||
|
||||
# Switch tab via number key '4'
|
||||
app._handle_key(ord("4"))
|
||||
self.assertEqual(app.current_tab, 3)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,224 @@
|
||||
#!/usr/bin/env python3
|
||||
"""test_tmux_auto_approver.py — Unit tests for Tmux worker management and regex auto-approver."""
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parent.parent
|
||||
sys.path.insert(0, str(REPO_ROOT / "bin"))
|
||||
|
||||
import tmux_auto_approver
|
||||
from tmux_auto_approver import (
|
||||
DEFAULT_RULES,
|
||||
GUARDRAIL_PATTERNS,
|
||||
AutoApproverRunner,
|
||||
AutoApproverState,
|
||||
MatchRule,
|
||||
MatchVerdict,
|
||||
RegexApproverEngine,
|
||||
TmuxPaneInfo,
|
||||
TmuxWorkerTally,
|
||||
gather_tmux_tally,
|
||||
infer_agent_for_session,
|
||||
)
|
||||
|
||||
|
||||
class TestRegexApproverEngine(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.engine = RegexApproverEngine(DEFAULT_RULES)
|
||||
|
||||
def test_muse_code_run_numbered_match(self):
|
||||
text = """
|
||||
Terminal output before...
|
||||
Would you like to run the following bash command?
|
||||
echo "hello"
|
||||
› 1. Yes, proceed (y)
|
||||
2. No, skip (n)
|
||||
"""
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertTrue(verdict.matched)
|
||||
self.assertEqual(verdict.rule_id, "muse_code_run_numbered")
|
||||
self.assertEqual(verdict.key, "1")
|
||||
self.assertFalse(verdict.press_enter)
|
||||
|
||||
def test_muse_code_run_yn_match(self):
|
||||
text = "Some actions\n› 1. Yes, proceed (y)\n"
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertTrue(verdict.matched)
|
||||
self.assertIn("muse_code_run", verdict.rule_id)
|
||||
self.assertEqual(verdict.key, "1")
|
||||
|
||||
def test_muse_code_allow_execution_match(self):
|
||||
text = "Allow execution of script /tmp/test.sh? [y/N]"
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertTrue(verdict.matched)
|
||||
self.assertEqual(verdict.rule_id, "muse_code_allow_execution")
|
||||
self.assertEqual(verdict.key, "y")
|
||||
self.assertTrue(verdict.press_enter)
|
||||
|
||||
def test_choice_abc_match(self):
|
||||
text = "Select option from the choices below:\nA) Deploy to production\nB) Staging"
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertTrue(verdict.matched)
|
||||
self.assertEqual(verdict.rule_id, "choice_abc")
|
||||
self.assertEqual(verdict.key, "A")
|
||||
self.assertTrue(verdict.press_enter)
|
||||
|
||||
def test_menu_numbered_match(self):
|
||||
text = "Option: Please pick a number:\n(1) Accept terms\n(2) Decline"
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertTrue(verdict.matched)
|
||||
self.assertEqual(verdict.rule_id, "menu_numbered")
|
||||
self.assertEqual(verdict.key, "1")
|
||||
self.assertTrue(verdict.press_enter)
|
||||
|
||||
def test_confirm_yn_match(self):
|
||||
text = "Do you want to continue? [y/n]: "
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertTrue(verdict.matched)
|
||||
self.assertEqual(verdict.rule_id, "confirm_yn")
|
||||
self.assertEqual(verdict.key, "y")
|
||||
self.assertTrue(verdict.press_enter)
|
||||
|
||||
def test_enter_to_continue_match(self):
|
||||
text = "Task completed successfully. Press [Enter] to continue..."
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertTrue(verdict.matched)
|
||||
self.assertEqual(verdict.rule_id, "enter_to_continue")
|
||||
self.assertEqual(verdict.key, "Enter")
|
||||
|
||||
def test_guardrail_sudo_password_blocked(self):
|
||||
text = "[sudo] password for super: "
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertFalse(verdict.matched)
|
||||
self.assertTrue(verdict.is_blocked)
|
||||
self.assertIn("guardrail", verdict.blocked_reason.lower())
|
||||
|
||||
def test_guardrail_passkey_blocked(self):
|
||||
text = "Insert security key or enter passkey PIN:"
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertFalse(verdict.matched)
|
||||
self.assertTrue(verdict.is_blocked)
|
||||
self.assertIn("guardrail", verdict.blocked_reason.lower())
|
||||
|
||||
def test_guardrail_destructive_command_blocked(self):
|
||||
text = "Running dangerous cleanup: rm -rf /"
|
||||
verdict = self.engine.evaluate(text)
|
||||
self.assertFalse(verdict.matched)
|
||||
self.assertTrue(verdict.is_blocked)
|
||||
self.assertIn("guardrail", verdict.blocked_reason.lower())
|
||||
|
||||
def test_empty_text_returns_unmatched(self):
|
||||
verdict = self.engine.evaluate("")
|
||||
self.assertFalse(verdict.matched)
|
||||
self.assertFalse(verdict.is_blocked)
|
||||
|
||||
|
||||
class TestAgentInference(unittest.TestCase):
|
||||
def test_infer_agent_names(self):
|
||||
self.assertEqual(infer_agent_for_session("/tmp/tmux-muse.sock", "worker-1"), "muse")
|
||||
self.assertEqual(infer_agent_for_session("/tmp/tmux-pip.sock", "agent-job"), "pip")
|
||||
self.assertEqual(infer_agent_for_session("/tmp/tmux-1000/default", "646-retention"), "646")
|
||||
self.assertEqual(infer_agent_for_session("/tmp/tmux-1000/default", "opm"), "opm")
|
||||
self.assertEqual(infer_agent_for_session("/tmp/tmux-1000/default", "dev-test"), "dev")
|
||||
self.assertEqual(infer_agent_for_session("/tmp/tmux-1000/default", "def"), "def")
|
||||
self.assertEqual(infer_agent_for_session("/tmp/tmux-1000/lte", "main"), "host")
|
||||
|
||||
|
||||
class TestAutoApproverRunner(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp_dir = tempfile.TemporaryDirectory()
|
||||
self.orig_state = tmux_auto_approver.STATE_FILE
|
||||
self.orig_audit = tmux_auto_approver.AUDIT_LOG_FILE
|
||||
tmux_auto_approver.STATE_FILE = Path(self.temp_dir.name) / "test_state.json"
|
||||
tmux_auto_approver.AUDIT_LOG_FILE = Path(self.temp_dir.name) / "test_audit.jsonl"
|
||||
|
||||
def tearDown(self):
|
||||
tmux_auto_approver.STATE_FILE = self.orig_state
|
||||
tmux_auto_approver.AUDIT_LOG_FILE = self.orig_audit
|
||||
self.temp_dir.cleanup()
|
||||
|
||||
@patch("tmux_auto_approver.run_tmux_cmd")
|
||||
@patch("tmux_auto_approver.capture_pane_text")
|
||||
@patch("tmux_auto_approver.gather_tmux_tally")
|
||||
def test_run_once_dry_run_dispatches_match(self, mock_tally, mock_capture, mock_tmux_cmd):
|
||||
mock_pane = TmuxPaneInfo(
|
||||
socket="/tmp/tmux-1000/default",
|
||||
session="muse",
|
||||
window_idx=0,
|
||||
pane_id="%37",
|
||||
pane_pid=12345,
|
||||
current_command="muse-bin",
|
||||
active=True,
|
||||
attached=True,
|
||||
title="muse terminal",
|
||||
agent_node="muse",
|
||||
auto_approve=True,
|
||||
)
|
||||
|
||||
mock_tally.return_value = TmuxWorkerTally(
|
||||
total_sockets=1,
|
||||
total_sessions=1,
|
||||
total_panes=1,
|
||||
active_workers=1,
|
||||
by_agent={"muse": {"sessions": 1, "panes": 1, "active_commands": ["muse-bin"], "auto_approve": True}},
|
||||
panes=[mock_pane],
|
||||
)
|
||||
|
||||
mock_capture.return_value = "Would you like to run the following?\n› 1. Yes, proceed (y)"
|
||||
|
||||
runner = AutoApproverRunner(dry_run=True)
|
||||
results = runner.run_once()
|
||||
|
||||
self.assertEqual(len(results), 1)
|
||||
self.assertEqual(results[0]["action"], "DRY_RUN_MATCH")
|
||||
self.assertEqual(results[0]["key_sent"], "1")
|
||||
self.assertEqual(results[0]["rule_name"], "Muse Code Run (Numbered)")
|
||||
|
||||
# Verify deduplication within 15 seconds
|
||||
results2 = runner.run_once()
|
||||
self.assertEqual(len(results2), 0)
|
||||
|
||||
@patch("tmux_auto_approver.gather_tmux_tally")
|
||||
def test_run_once_global_disabled(self, mock_tally):
|
||||
runner = AutoApproverRunner(dry_run=True)
|
||||
runner.state.global_enabled = False
|
||||
runner.state.save()
|
||||
results = runner.run_once()
|
||||
self.assertEqual(len(results), 1)
|
||||
self.assertEqual(results[0]["status"], "disabled")
|
||||
|
||||
|
||||
class TestTallyGathering(unittest.TestCase):
|
||||
@patch("tmux_auto_approver.get_existing_sockets")
|
||||
@patch("tmux_auto_approver.run_tmux_cmd")
|
||||
def test_gather_tmux_tally_parsing(self, mock_run_cmd, mock_sockets):
|
||||
mock_sockets.return_value = ["/tmp/tmux-1000/default"]
|
||||
# Format: #{session_name}___#{window_index}___#{pane_id}___#{pane_pid}___#{pane_current_command}___#{pane_active}___#{session_attached}___#{pane_title}
|
||||
mock_run_cmd.return_value = (
|
||||
0,
|
||||
"muse___0___%1___1001___muse-bin___1___1___muse worker\n"
|
||||
"dev___0___%2___1002___bash___0___0___dev terminal\n",
|
||||
"",
|
||||
)
|
||||
|
||||
state = AutoApproverState()
|
||||
tally = gather_tmux_tally(state)
|
||||
|
||||
self.assertEqual(tally.total_sockets, 1)
|
||||
self.assertEqual(tally.total_sessions, 2)
|
||||
self.assertEqual(tally.total_panes, 2)
|
||||
self.assertEqual(tally.active_workers, 1) # only muse-bin is active, bash is shell
|
||||
self.assertEqual(len(tally.panes), 2)
|
||||
self.assertEqual(tally.panes[0].agent_node, "muse")
|
||||
self.assertEqual(tally.panes[1].agent_node, "dev")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user