@annals/agent-mesh 0.12.0

package/dist/chunk-GIEYJIVW.js

@@ -0,0 +1,936 @@
+#!/usr/bin/env node
+
+// src/commands/list.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+
+// src/utils/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".agent-mesh");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var PIDS_DIR = join(CONFIG_DIR, "pids");
+var LOGS_DIR = join(CONFIG_DIR, "logs");
+function ensureDir() {
+  for (const dir of [CONFIG_DIR, PIDS_DIR, LOGS_DIR]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+  }
+}
+function loadConfig() {
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { agents: {} };
+  }
+}
+function saveConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+}
+function updateConfig(partial) {
+  const existing = loadConfig();
+  saveConfig({ ...existing, ...partial });
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function getPidsDir() {
+  ensureDir();
+  return PIDS_DIR;
+}
+function getLogsDir() {
+  ensureDir();
+  return LOGS_DIR;
+}
+function getAgent(name) {
+  return loadConfig().agents[name];
+}
+function addAgent(name, entry) {
+  const config = loadConfig();
+  config.agents[name] = entry;
+  saveConfig(config);
+}
+function removeAgent(name) {
+  const config = loadConfig();
+  delete config.agents[name];
+  saveConfig(config);
+}
+function saveAgentStartTime(name, ts) {
+  const config = loadConfig();
+  if (config.agents[name]) {
+    config.agents[name].startedAt = ts;
+    saveConfig(config);
+  }
+}
+function listAgents() {
+  return loadConfig().agents;
+}
+function findAgentByAgentId(agentId) {
+  const agents = loadConfig().agents;
+  for (const [name, entry] of Object.entries(agents)) {
+    if (entry.agentId === agentId) return { name, entry };
+  }
+  return void 0;
+}
+var AGENTS_DIR = join(CONFIG_DIR, "agents");
+function getAgentWorkspaceDir(name) {
+  const dir = join(AGENTS_DIR, name);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+function uniqueSlug(base) {
+  const agents = loadConfig().agents;
+  const slug = slugify(base);
+  if (!(slug in agents)) return slug;
+  for (let i = 2; ; i++) {
+    const candidate = `${slug}-${i}`;
+    if (!(candidate in agents)) return candidate;
+  }
+}
+
+// src/utils/process-manager.ts
+import { spawn, execSync } from "child_process";
+import {
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  unlinkSync,
+  readdirSync,
+  statSync,
+  renameSync,
+  openSync,
+  closeSync
+} from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var MAX_LOG_SIZE = 5 * 1024 * 1024;
+var MAX_LOG_FILES = 3;
+function writePid(name, pid) {
+  const pidPath = join2(getPidsDir(), `${name}.pid`);
+  writeFileSync2(pidPath, String(pid), { mode: 384 });
+}
+function readPid(name) {
+  try {
+    const raw = readFileSync2(join2(getPidsDir(), `${name}.pid`), "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function removePid(name) {
+  try {
+    unlinkSync(join2(getPidsDir(), `${name}.pid`));
+  } catch {
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanStalePids() {
+  let files;
+  try {
+    files = readdirSync(getPidsDir());
+  } catch {
+    return;
+  }
+  for (const file of files) {
+    if (!file.endsWith(".pid")) continue;
+    const name = file.slice(0, -4);
+    const pid = readPid(name);
+    if (pid !== null && !isProcessAlive(pid)) {
+      removePid(name);
+    }
+  }
+}
+function getLogPath(name) {
+  return join2(getLogsDir(), `${name}.log`);
+}
+function rotateLogIfNeeded(name) {
+  const logPath = getLogPath(name);
+  try {
+    const stat = statSync(logPath);
+    if (stat.size <= MAX_LOG_SIZE) return;
+    try {
+      unlinkSync(`${logPath}.${MAX_LOG_FILES - 1}`);
+    } catch {
+    }
+    for (let i = MAX_LOG_FILES - 2; i >= 0; i--) {
+      const from = i === 0 ? logPath : `${logPath}.${i}`;
+      const to = `${logPath}.${i + 1}`;
+      try {
+        renameSync(from, to);
+      } catch {
+      }
+    }
+    writeFileSync2(logPath, "", { mode: 384 });
+  } catch {
+  }
+}
+var _loginEnvCache = null;
+function getLoginShellEnv() {
+  if (_loginEnvCache) return _loginEnvCache;
+  try {
+    const shell = process.env.SHELL || "/bin/zsh";
+    const isZsh = shell.endsWith("/zsh");
+    const cmd = isZsh ? `${shell} -c 'source ~/.zshrc 2>/dev/null; env'` : `${shell} -li -c env`;
+    const output = execSync(cmd, {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const env = {};
+    for (const line of output.split("\n")) {
+      const eq = line.indexOf("=");
+      if (eq > 0) env[line.slice(0, eq)] = line.slice(eq + 1);
+    }
+    _loginEnvCache = env;
+    return env;
+  } catch {
+    return {};
+  }
+}
+function spawnBackground(name, entry, platformToken) {
+  rotateLogIfNeeded(name);
+  const logPath = getLogPath(name);
+  const logFd = openSync(logPath, "a", 384);
+  const args = [
+    process.argv[1],
+    "connect",
+    entry.agentType,
+    "--agent-id",
+    entry.agentId,
+    "--bridge-url",
+    entry.bridgeUrl
+  ];
+  if (entry.gatewayUrl) args.push("--gateway-url", entry.gatewayUrl);
+  if (entry.gatewayToken) args.push("--gateway-token", entry.gatewayToken);
+  if (entry.projectPath) args.push("--project", entry.projectPath);
+  if (entry.sandbox) args.push("--sandbox");
+  const loginEnv = getLoginShellEnv();
+  const env = {};
+  for (const [k, v] of Object.entries(loginEnv)) {
+    if (v !== void 0) env[k] = v;
+  }
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v !== void 0 && k !== "PATH") env[k] = v;
+  }
+  const tokenForChild = entry.bridgeToken || platformToken;
+  if (tokenForChild) env.AGENT_BRIDGE_TOKEN = tokenForChild;
+  const pathSet = /* @__PURE__ */ new Set();
+  for (const src of [loginEnv.PATH, process.env.PATH, "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"]) {
+    if (src) for (const p of src.split(":")) {
+      if (p) pathSet.add(p);
+    }
+  }
+  env.PATH = [...pathSet].join(":");
+  const agentWorkspaceDir = join2(homedir2(), ".agent-mesh", "agents", name);
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    cwd: entry.projectPath || agentWorkspaceDir,
+    env
+  });
+  const pid = child.pid;
+  child.unref();
+  closeSync(logFd);
+  writePid(name, pid);
+  saveAgentStartTime(name, Date.now());
+  return pid;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function stopProcess(name) {
+  const pid = readPid(name);
+  if (pid === null || !isProcessAlive(pid)) {
+    removePid(name);
+    return false;
+  }
+  process.kill(pid, "SIGTERM");
+  for (let i = 0; i < 30; i++) {
+    await sleep(100);
+    if (!isProcessAlive(pid)) {
+      removePid(name);
+      return true;
+    }
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+  removePid(name);
+  return true;
+}
+
+// src/utils/table.ts
+var RESET = "\x1B[0m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var GRAY = "\x1B[90m";
+var BOLD = "\x1B[1m";
+function pad(text, width, align = "left") {
+  const plain = text.replace(/\x1b\[[0-9;]*m/g, "");
+  const diff = width - plain.length;
+  if (diff <= 0) return text;
+  const padding = " ".repeat(diff);
+  return align === "right" ? padding + text : text + padding;
+}
+function renderTable(columns, rows) {
+  const lines = [];
+  const header = columns.map((col) => pad(col.label, col.width, col.align)).join("");
+  lines.push(`  ${BOLD}${GRAY}${header}${RESET}`);
+  for (const row of rows) {
+    const cells = columns.map((col) => {
+      const raw = row[col.key] ?? "";
+      const formatted = col.format ? col.format(raw) : raw;
+      return pad(formatted, col.width, col.align);
+    });
+    lines.push(`  ${cells.join("")}`);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/list.ts
+var ALT_ON = "\x1B[?1049h";
+var ALT_OFF = "\x1B[?1049l";
+var CUR_HIDE = "\x1B[?25l";
+var CUR_SHOW = "\x1B[?25h";
+var HOME = "\x1B[H";
+var CLR = "\x1B[K";
+var DIM = "\x1B[2m";
+var SPLIT_MIN_WIDTH = 90;
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function pad2(text, width) {
+  const plain = text.replace(/\x1b\[[0-9;]*m/g, "");
+  const diff = width - plain.length;
+  return diff > 0 ? text + " ".repeat(diff) : text;
+}
+function truncate(text, maxLen) {
+  const plain = text.replace(/\x1b\[[0-9;]*m/g, "");
+  if (plain.length <= maxLen) return text;
+  return plain.slice(0, maxLen - 1) + "\u2026";
+}
+async function fetchRemoteStatus(token) {
+  const map = {};
+  if (!token) return map;
+  try {
+    const res = await fetch("https://agents.hot/api/developer/agents", {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (res.ok) {
+      for (const a of await res.json()) {
+        map[a.id] = a.is_online;
+      }
+    }
+  } catch {
+  }
+  return map;
+}
+function buildRows(agents, remote) {
+  return Object.keys(agents).sort().map((name) => {
+    const entry = agents[name];
+    const pidNum = readPid(name);
+    const alive = pidNum !== null && isProcessAlive(pidNum);
+    const isOnline = remote[entry.agentId];
+    let status, statusColor;
+    if (alive && isOnline === true) {
+      status = "\u25CF online";
+      statusColor = GREEN;
+    } else if (alive) {
+      status = "\u25D0 running";
+      statusColor = YELLOW;
+    } else {
+      status = "\u25CB stopped";
+      statusColor = GRAY;
+    }
+    return {
+      name,
+      entry,
+      type: entry.agentType,
+      status,
+      statusColor,
+      pid: alive && pidNum !== null ? String(pidNum) : "\u2014",
+      alive,
+      url: `agents.hot/agents/${entry.agentId}`
+    };
+  });
+}
+function getFailReason(name) {
+  try {
+    const logPath = getLogPath(name);
+    if (!existsSync2(logPath)) return null;
+    const content = readFileSync3(logPath, "utf-8");
+    const lines = content.split("\n").slice(-20);
+    const text = lines.join("\n");
+    if (/token.*revoked|revoked.*token/i.test(text)) {
+      return "Token revoked \u2014 run `agent-mesh login` to get a new token";
+    }
+    if (/auth_failed|Not authenticated/i.test(text)) {
+      return "Authentication failed \u2014 check your token";
+    }
+    if (/ECONNREFUSED|Gateway unreachable/i.test(text)) {
+      return "Agent runtime unreachable \u2014 check if gateway is running";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getRecentLogLines(name, count) {
+  try {
+    const logPath = getLogPath(name);
+    if (!existsSync2(logPath)) return [];
+    const content = readFileSync3(logPath, "utf-8");
+    return content.split("\n").filter((l) => l.trim().length > 0).slice(-count);
+  } catch {
+    return [];
+  }
+}
+function estimateActiveSessions(name) {
+  try {
+    const logPath = getLogPath(name);
+    if (!existsSync2(logPath)) return 0;
+    const content = readFileSync3(logPath, "utf-8");
+    const lines = content.split("\n").slice(-200);
+    let active = 0;
+    for (const line of lines) {
+      if (/Message received/.test(line)) active++;
+      if (/Request done|request.*error|Session cleaned/.test(line)) active = Math.max(0, active - 1);
+    }
+    return active;
+  } catch {
+    return 0;
+  }
+}
+function formatUptime(startedAt) {
+  if (!startedAt) return "\u2014";
+  const ms = Date.now() - startedAt;
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  const rem = m % 60;
+  return rem > 0 ? `${h}h ${rem}m` : `${h}h`;
+}
+function formatLogLine(line) {
+  return line.replace(/^\d{4}-\d{2}-\d{2} (\d{2}:\d{2}):\d{2}\s+/, "$1 ");
+}
+function colorizeLogLine(line) {
+  if (/\bERROR\b/.test(line)) return RED + line + RESET;
+  if (/\bWARN\b/.test(line)) return YELLOW + line + RESET;
+  if (/\bINFO\b/.test(line)) return line;
+  return GRAY + line + RESET;
+}
+var W_NAME = 20;
+var W_TYPE = 12;
+var W_STATUS = 14;
+var W_PID = 8;
+function renderSingleScreen(rows, sel, msg) {
+  const out = [];
+  const ln = (s = "") => out.push(s + CLR);
+  ln();
+  ln(`  ${BOLD}AGENT BRIDGE${RESET}`);
+  ln();
+  if (rows.length === 0) {
+    ln(`  No agents registered. Use ${BOLD}agent-mesh connect --setup <url>${RESET} to add one.`);
+    ln();
+    ln(`  ${DIM}q quit${RESET}`);
+    return out.join("\n");
+  }
+  ln(`${BOLD}${GRAY}  ${"NAME".padEnd(W_NAME)}${"TYPE".padEnd(W_TYPE)}${"STATUS".padEnd(W_STATUS)}${"PID".padStart(W_PID)}  URL${RESET}`);
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    const isSel = i === sel;
+    const mark = isSel ? `${GREEN}\u25B8${RESET}` : " ";
+    const nm = isSel ? `${BOLD}${r.name}${RESET}` : r.name;
+    ln(`${mark} ${pad2(nm, W_NAME)}${pad2(r.type, W_TYPE)}${pad2(`${r.statusColor}${r.status}${RESET}`, W_STATUS)}${r.pid.padStart(W_PID)}  ${GRAY}${r.url}${RESET}`);
+  }
+  let on = 0, run = 0, off = 0;
+  for (const r of rows) {
+    if (r.status.includes("online")) on++;
+    else if (r.status.includes("running")) run++;
+    else off++;
+  }
+  const parts = [`${rows.length} agents`];
+  if (on) parts.push(`${on} online`);
+  if (run) parts.push(`${run} running`);
+  if (off) parts.push(`${off} stopped`);
+  ln();
+  ln(`  ${GRAY}${parts.join(" \xB7 ")}${RESET}`);
+  ln();
+  ln(msg ? `  ${msg}` : "");
+  ln();
+  ln(`  ${DIM}\u2191\u2193${RESET} navigate  ${DIM}s${RESET} start  ${DIM}x${RESET} stop  ${DIM}r${RESET} restart  ${DIM}l${RESET} logs  ${DIM}o${RESET} open  ${DIM}d${RESET} remove  ${DIM}q${RESET} quit`);
+  return out.join("\n");
+}
+function renderSplitScreen(rows, sel, msg, rightFocus, logScroll) {
+  const tw = process.stdout.columns || 120;
+  const th = process.stdout.rows || 30;
+  const LEFT_W = Math.max(22, Math.min(30, Math.floor(tw * 0.3)));
+  const RIGHT_W = tw - LEFT_W - 1;
+  const BODY_H = Math.max(4, th - 6);
+  const selRow = rows[sel];
+  const leftLines = [];
+  if (rows.length === 0) {
+    leftLines.push(`  ${GRAY}No agents${RESET}`);
+    leftLines.push(`  ${DIM}connect --setup <url>${RESET}`);
+  } else {
+    for (let i = 0; i < rows.length; i++) {
+      const r = rows[i];
+      const isSel = i === sel;
+      const mark = isSel ? rightFocus ? `${DIM}\u25B8${RESET}` : `${GREEN}\u25B8${RESET}` : " ";
+      const nameW = LEFT_W - 4;
+      const nm = truncate(isSel ? `${BOLD}${r.name}${RESET}` : r.name, nameW);
+      leftLines.push(`${mark} ${pad2(nm, nameW)} ${r.statusColor}${r.status.slice(0, 2)}${RESET}`);
+    }
+  }
+  const rightLines = [];
+  const rw = RIGHT_W - 3;
+  if (!selRow) {
+    rightLines.push(`${GRAY}No agent selected${RESET}`);
+  } else {
+    const sessions = selRow.alive ? estimateActiveSessions(selRow.name) : 0;
+    const uptime = selRow.alive ? formatUptime(selRow.entry.startedAt) : "\u2014";
+    const pidStr = selRow.alive ? `(PID ${selRow.pid})` : "";
+    const statusStr = `${selRow.statusColor}${selRow.status}${RESET}${pidStr ? ` ${GRAY}${pidStr}${RESET}` : ""}`;
+    rightLines.push(`${BOLD}${truncate(selRow.name, rw)}${RESET}`);
+    rightLines.push("\u2500".repeat(Math.min(rw, 40)));
+    rightLines.push(`${GRAY}Type:    ${RESET}${selRow.type}`);
+    rightLines.push(`${GRAY}Status:  ${RESET}${statusStr}`);
+    rightLines.push(`${GRAY}Sessions:${RESET} ${sessions > 0 ? `${GREEN}${sessions} active${RESET}` : `${GRAY}\u2014${RESET}`}`);
+    rightLines.push(`${GRAY}Uptime:  ${RESET}${uptime}`);
+    rightLines.push(`${GRAY}URL:     ${RESET}${GRAY}${truncate(selRow.url, rw - 9)}${RESET}`);
+    rightLines.push("");
+    const logHeaderLine = `${DIM}\u2500\u2500 Recent Log ${"\u2500".repeat(Math.max(0, Math.min(rw - 14, 20)))}${RESET}`;
+    rightLines.push(logHeaderLine);
+    const logLines = getRecentLogLines(selRow.name, 40);
+    if (logLines.length === 0) {
+      rightLines.push(`${GRAY}No log yet${RESET}`);
+    } else {
+      const logAreaH = Math.max(3, BODY_H - rightLines.length - 1);
+      const maxScroll = Math.max(0, logLines.length - logAreaH);
+      const clampedScroll = Math.min(logScroll, maxScroll);
+      const visibleLines = logLines.slice(
+        Math.max(0, logLines.length - logAreaH - clampedScroll),
+        logLines.length - clampedScroll || void 0
+      );
+      for (const l of visibleLines) {
+        const formatted = colorizeLogLine(formatLogLine(l));
+        rightLines.push(truncate(formatted, rw));
+      }
+      if (maxScroll > 0) {
+        const scrollInfo = clampedScroll > 0 ? `${GRAY}\u2191\u2193 scroll (${clampedScroll}/${maxScroll})${RESET}` : `${GRAY}\u2191 scroll up for more${RESET}`;
+        rightLines.push(scrollInfo);
+      }
+    }
+  }
+  const out = [HOME];
+  out.push(`${"\u2500".repeat(LEFT_W)}\u252C${"\u2500".repeat(RIGHT_W)}${CLR}`);
+  const leftHeader = pad2(`  ${BOLD}AGENT BRIDGE${RESET}`, LEFT_W);
+  const rightHeader = selRow ? `  ${GRAY}${selRow.type}${RESET}` : "  ";
+  out.push(`${leftHeader}\u2502${rightHeader}${CLR}`);
+  for (let row = 0; row < BODY_H; row++) {
+    const leftCell = leftLines[row] ?? "";
+    const rightCell = rightLines[row] ?? "";
+    const leftPad = LEFT_W - leftCell.replace(/\x1b\[[0-9;]*m/g, "").length;
+    const leftFull = `  ${leftCell}${leftPad > 0 ? " ".repeat(Math.max(0, leftPad - 2)) : ""}`;
+    const rightFull = `  ${rightCell}`;
+    out.push(`${truncate(leftFull, LEFT_W)}\u2502${rightFull}${CLR}`);
+  }
+  let on = 0, run = 0, off = 0;
+  for (const r of rows) {
+    if (r.status.includes("online")) on++;
+    else if (r.status.includes("running")) run++;
+    else off++;
+  }
+  const summaryParts = [`${rows.length} agent${rows.length !== 1 ? "s" : ""}`];
+  if (on) summaryParts.push(`${GREEN}${on} online${RESET}`);
+  if (run) summaryParts.push(`${YELLOW}${run} running${RESET}`);
+  if (off) summaryParts.push(`${GRAY}${off} stopped${RESET}`);
+  const summary = `  ${summaryParts.join(" \xB7 ")}`;
+  out.push(`${"\u2500".repeat(LEFT_W)}\u2534${"\u2500".repeat(RIGHT_W)}${CLR}`);
+  out.push(`${summary}${CLR}`);
+  out.push(msg ? `  ${msg}${CLR}` : `${CLR}`);
+  const focusHint = rightFocus ? `${DIM}\u2191\u2193${RESET} scroll log  ${DIM}\u2190/Esc${RESET} focus list  ${DIM}l${RESET} full logs  ${DIM}q${RESET} quit` : `${DIM}\u2191\u2193${RESET} navigate  ${DIM}s${RESET} start  ${DIM}x${RESET} stop  ${DIM}r${RESET} restart  ${DIM}l${RESET} logs  ${DIM}o${RESET} open  ${DIM}Tab/\u2192${RESET} detail  ${DIM}q${RESET} quit`;
+  out.push(`  ${focusHint}${CLR}`);
+  return out.join("\n");
+}
+var ListTUI = class {
+  rows = [];
+  sel = 0;
+  msg = "";
+  ok = true;
+  busy = false;
+  confirm = null;
+  refreshTimer = null;
+  rightRefreshTimer = null;
+  msgTimer = null;
+  token;
+  keyHandler = (k) => this.onKey(k);
+  resizeHandler = () => this.draw();
+  // Split layout state
+  rightFocus = false;
+  logScroll = 0;
+  get isSplit() {
+    return (process.stdout.columns || 80) >= SPLIT_MIN_WIDTH;
+  }
+  async run() {
+    if (!process.stdin.isTTY) {
+      await this.staticFallback();
+      return;
+    }
+    this.ok = true;
+    process.stdout.write(ALT_ON + CUR_HIDE);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    await this.refresh();
+    this.draw();
+    this.refreshTimer = setInterval(() => {
+      if (!this.ok || this.busy) return;
+      this.refresh().then(() => this.draw());
+    }, 5e3);
+    this.rightRefreshTimer = setInterval(() => {
+      if (!this.ok || this.busy) return;
+      this.draw();
+    }, 2e3);
+    process.stdin.on("data", this.keyHandler);
+    process.stdout.on("resize", this.resizeHandler);
+  }
+  async refresh() {
+    cleanStalePids();
+    const cfg = loadConfig();
+    this.token = cfg.token;
+    const remote = await fetchRemoteStatus(cfg.token);
+    this.rows = buildRows(cfg.agents, remote);
+    if (this.sel >= this.rows.length) this.sel = Math.max(0, this.rows.length - 1);
+  }
+  draw() {
+    if (!this.ok) return;
+    const screen = this.isSplit ? renderSplitScreen(this.rows, this.sel, this.msg, this.rightFocus, this.logScroll) : renderSingleScreen(this.rows, this.sel, this.msg);
+    process.stdout.write(HOME + screen);
+  }
+  flash(m, ms = 3e3) {
+    this.msg = m;
+    if (this.msgTimer) clearTimeout(this.msgTimer);
+    if (ms > 0) {
+      this.msgTimer = setTimeout(() => {
+        this.msg = "";
+        this.draw();
+      }, ms);
+    }
+  }
+  onKey(k) {
+    if (k === "") {
+      this.exit();
+      return;
+    }
+    if (!this.busy && !this.confirm && (k === "q" || k === "Q" || k === "\x1B")) {
+      if (this.rightFocus && k === "\x1B") {
+        this.rightFocus = false;
+        this.logScroll = 0;
+        this.draw();
+        return;
+      }
+      if (!this.rightFocus) {
+        this.exit();
+        return;
+      }
+    }
+    if (this.confirm) {
+      if (k === "y" || k === "Y") {
+        const name = this.confirm.name;
+        this.confirm = null;
+        this.doRemove(name);
+      } else {
+        this.confirm = null;
+        this.flash("", 0);
+        this.draw();
+      }
+      return;
+    }
+    if (this.busy) return;
+    if ((k === "	" || k === "\x1B[C") && this.isSplit) {
+      this.rightFocus = true;
+      this.logScroll = 0;
+      this.draw();
+      return;
+    }
+    if (k === "\x1B[D" && this.rightFocus) {
+      this.rightFocus = false;
+      this.logScroll = 0;
+      this.draw();
+      return;
+    }
+    if (k === "\x1B[A" || k === "k") {
+      if (this.rightFocus) {
+        this.logScroll++;
+        this.draw();
+      } else if (this.sel > 0) {
+        this.sel--;
+        this.logScroll = 0;
+        this.draw();
+      }
+      return;
+    }
+    if (k === "\x1B[B" || k === "j") {
+      if (this.rightFocus) {
+        this.logScroll = Math.max(0, this.logScroll - 1);
+        this.draw();
+      } else if (this.sel < this.rows.length - 1) {
+        this.sel++;
+        this.logScroll = 0;
+        this.draw();
+      }
+      return;
+    }
+    const row = this.rows[this.sel];
+    if (!row) return;
+    switch (k.toLowerCase()) {
+      case "s":
+        this.doStart(row);
+        break;
+      case "x":
+        this.doStop(row);
+        break;
+      case "r":
+        this.doRestart(row);
+        break;
+      case "l":
+        this.doLogs(row);
+        break;
+      case "o":
+        this.doOpen(row);
+        break;
+      case "\r":
+        this.doOpen(row);
+        break;
+      case "d":
+        this.confirm = { name: row.name };
+        this.flash(`${YELLOW}Remove ${BOLD}${row.name}${RESET}${YELLOW}? Press y to confirm${RESET}`, 15e3);
+        this.draw();
+        break;
+    }
+  }
+  async doStart(row) {
+    if (row.alive) {
+      this.flash(`${YELLOW}\u2298${RESET} ${BOLD}${row.name}${RESET} already running`);
+      this.draw();
+      return;
+    }
+    this.busy = true;
+    this.flash(`Starting ${row.name}...`, 1e4);
+    this.draw();
+    const pid = spawnBackground(row.name, row.entry, this.token);
+    await sleep2(600);
+    await this.refresh();
+    this.busy = false;
+    if (!isProcessAlive(pid)) {
+      const reason = getFailReason(row.name);
+      this.flash(reason ? `${RED}\u2717${RESET} ${BOLD}${row.name}${RESET} \u2014 ${reason}` : `${RED}\u2717${RESET} ${BOLD}${row.name}${RESET} failed to start \u2014 press ${BOLD}l${RESET} for logs`);
+    } else {
+      this.flash(`${GREEN}\u2713${RESET} ${BOLD}${row.name}${RESET} started (PID: ${pid})`);
+      this.schedulePostStartCheck(row.name, pid);
+    }
+    this.draw();
+  }
+  async doStop(row) {
+    if (!row.alive) {
+      this.flash(`${YELLOW}\u2298${RESET} ${BOLD}${row.name}${RESET} not running`);
+      this.draw();
+      return;
+    }
+    this.busy = true;
+    this.flash(`Stopping ${row.name}...`, 1e4);
+    this.draw();
+    const ok = await stopProcess(row.name);
+    await this.refresh();
+    this.busy = false;
+    this.flash(ok ? `${GREEN}\u2713${RESET} ${BOLD}${row.name}${RESET} stopped` : `${YELLOW}\u2298${RESET} ${BOLD}${row.name}${RESET} was not running`);
+    this.draw();
+  }
+  async doRestart(row) {
+    this.busy = true;
+    this.flash(`Restarting ${row.name}...`, 1e4);
+    this.draw();
+    if (row.alive) await stopProcess(row.name);
+    await sleep2(500);
+    const pid = spawnBackground(row.name, row.entry, this.token);
+    await sleep2(600);
+    await this.refresh();
+    this.busy = false;
+    if (!isProcessAlive(pid)) {
+      const reason = getFailReason(row.name);
+      this.flash(reason ? `${RED}\u2717${RESET} ${BOLD}${row.name}${RESET} \u2014 ${reason}` : `${RED}\u2717${RESET} ${BOLD}${row.name}${RESET} failed to restart \u2014 press ${BOLD}l${RESET} for logs`);
+    } else {
+      this.flash(`${GREEN}\u2713${RESET} ${BOLD}${row.name}${RESET} restarted (PID: ${pid})`);
+      this.schedulePostStartCheck(row.name, pid);
+    }
+    this.draw();
+  }
+  schedulePostStartCheck(name, pid) {
+    setTimeout(async () => {
+      if (!this.ok || this.busy) return;
+      if (!isProcessAlive(pid)) {
+        await this.refresh();
+        const reason = getFailReason(name);
+        this.flash(reason ? `${RED}\u2717${RESET} ${BOLD}${name}${RESET} \u2014 ${reason}` : `${RED}\u2717${RESET} ${BOLD}${name}${RESET} exited shortly after start \u2014 press ${BOLD}l${RESET} for logs`, 8e3);
+        this.draw();
+      }
+    }, 3e3);
+  }
+  async doLogs(row) {
+    const logPath = getLogPath(row.name);
+    if (!existsSync2(logPath)) {
+      this.flash(`${YELLOW}No logs yet for ${BOLD}${row.name}${RESET}`);
+      this.draw();
+      return;
+    }
+    this.busy = true;
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    if (this.rightRefreshTimer) {
+      clearInterval(this.rightRefreshTimer);
+      this.rightRefreshTimer = null;
+    }
+    process.stdin.removeListener("data", this.keyHandler);
+    process.stdout.removeListener("resize", this.resizeHandler);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.stdout.write(ALT_OFF + CUR_SHOW);
+    console.log(`
+  \u2500\u2500\u2500 ${BOLD}${row.name}${RESET} (${row.type}) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    console.log(`  ${GRAY}${logPath}${RESET}`);
+    console.log(`  ${GRAY}Press Ctrl+C to return to list${RESET}
+`);
+    const noop = () => {
+    };
+    process.on("SIGINT", noop);
+    const tail = spawn2("tail", ["-f", "-n", "50", logPath], { stdio: "inherit" });
+    await new Promise((resolve) => {
+      tail.on("close", resolve);
+      tail.on("error", resolve);
+    });
+    process.removeListener("SIGINT", noop);
+    process.stdout.write(ALT_ON + CUR_HIDE);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", this.keyHandler);
+    process.stdout.on("resize", this.resizeHandler);
+    await this.refresh();
+    this.busy = false;
+    this.draw();
+    this.refreshTimer = setInterval(() => {
+      if (!this.ok || this.busy) return;
+      this.refresh().then(() => this.draw());
+    }, 5e3);
+    this.rightRefreshTimer = setInterval(() => {
+      if (!this.ok || this.busy) return;
+      this.draw();
+    }, 2e3);
+  }
+  doOpen(row) {
+    const url = `https://agents.hot/agents/${row.entry.agentId}`;
+    const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+    const child = spawn2(cmd, [url], { detached: true, stdio: "ignore" });
+    child.unref();
+    this.flash(`${GREEN}\u2713${RESET} Opened ${GRAY}${url}${RESET}`);
+    this.draw();
+  }
+  async doRemove(name) {
+    this.busy = true;
+    this.flash(`Removing ${name}...`, 1e4);
+    this.draw();
+    await stopProcess(name);
+    removeAgent(name);
+    removePid(name);
+    await this.refresh();
+    this.busy = false;
+    this.flash(`${GREEN}\u2713${RESET} ${BOLD}${name}${RESET} removed`);
+    this.draw();
+  }
+  exit() {
+    if (!this.ok) return;
+    this.ok = false;
+    if (this.refreshTimer) clearInterval(this.refreshTimer);
+    if (this.rightRefreshTimer) clearInterval(this.rightRefreshTimer);
+    if (this.msgTimer) clearTimeout(this.msgTimer);
+    process.stdout.removeListener("resize", this.resizeHandler);
+    process.stdout.write(ALT_OFF + CUR_SHOW);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.exit(0);
+  }
+  async staticFallback() {
+    cleanStalePids();
+    const cfg = loadConfig();
+    const names = Object.keys(cfg.agents);
+    if (names.length === 0) {
+      console.log("No agents registered.");
+      return;
+    }
+    const remote = await fetchRemoteStatus(cfg.token);
+    const rows = buildRows(cfg.agents, remote);
+    console.log("");
+    console.log(`  ${BOLD}${GRAY}${"NAME".padEnd(W_NAME)}${"TYPE".padEnd(W_TYPE)}${"STATUS".padEnd(W_STATUS)}${"PID".padStart(W_PID)}  URL${RESET}`);
+    for (const r of rows) {
+      console.log(`  ${pad2(`${BOLD}${r.name}${RESET}`, W_NAME)}${pad2(r.type, W_TYPE)}${pad2(`${r.statusColor}${r.status}${RESET}`, W_STATUS)}${r.pid.padStart(W_PID)}  ${GRAY}${r.url}${RESET}`);
+    }
+    console.log("");
+  }
+};
+function registerListCommand(program) {
+  program.command("list").alias("ls").description("Interactive agent management dashboard").action(async () => {
+    const tui = new ListTUI();
+    await tui.run();
+  });
+}
+
+export {
+  loadConfig,
+  updateConfig,
+  getConfigPath,
+  getAgent,
+  addAgent,
+  removeAgent,
+  listAgents,
+  findAgentByAgentId,
+  getAgentWorkspaceDir,
+  uniqueSlug,
+  writePid,
+  readPid,
+  removePid,
+  isProcessAlive,
+  getLogPath,
+  spawnBackground,
+  stopProcess,
+  RESET,
+  GREEN,
+  YELLOW,
+  GRAY,
+  BOLD,
+  renderTable,
+  ListTUI,
+  registerListCommand
+};