@tekyzinc/gsd-t 3.10.16 → 3.11.10

package/scripts/gsd-t-agent-dashboard-server.js

@@ -0,0 +1,424 @@
+#!/usr/bin/env node
+/**
+ * GSD-T Agent Topology Dashboard Server
+ * Zero-dep SSE server that tails events, heartbeat, context-meter, and
+ * supervisor state files, then streams structured named events to browser clients.
+ *
+ * Port: 7434 (separate from the existing metrics dashboard on 7433)
+ */
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULT_PORT = 7434;
+const KEEPALIVE_MS = 15000;
+const SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  "Connection": "keep-alive",
+  "Access-Control-Allow-Origin": "*",
+};
+
+// ── State Model ────────────────────────────────────────────────────────────
+
+const state = {
+  agents: new Map(),
+  sessions: new Map(),
+  context: { pct: 0, threshold: "normal", inputTokens: 0, windowSize: 200000, ts: null },
+  supervisor: null,
+  recentEvents: [],
+  contextHistory: [],
+  modelCounts: { opus: 0, sonnet: 0, haiku: 0 },
+  toolCount: 0,
+};
+
+const MAX_EVENTS = 200;
+const MAX_HISTORY = 200;
+
+// ── SSE Client Management ──────────────────────────────────────────────────
+
+const clients = new Set();
+
+function broadcast(eventName, data) {
+  const msg = `event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`;
+  for (const res of clients) {
+    try { res.write(msg); } catch { clients.delete(res); }
+  }
+}
+
+function sendSnapshot(res) {
+  const snapshot = {
+    agents: [...state.agents.values()],
+    sessions: [...state.sessions.values()].map(s => ({ ...s, childAgentIds: [...(s.childAgentIds || [])] })),
+    context: state.context,
+    supervisor: state.supervisor,
+    events: state.recentEvents.slice(-100),
+    contextHistory: state.contextHistory,
+    modelCounts: { ...state.modelCounts },
+    toolCount: state.toolCount,
+  };
+  res.write(`event: snapshot\ndata: ${JSON.stringify(snapshot)}\n\n`);
+}
+
+// ── File Tailing Helpers ───────────────────────────────────────────────────
+
+function parseJsonLine(line) {
+  if (!line || !line.trim()) return null;
+  try { return JSON.parse(line.trim()); } catch { return null; }
+}
+
+function tailFile(filePath, callback, interval) {
+  let offset = 0;
+  try { offset = fs.statSync(filePath).size; } catch { /* new file */ }
+
+  function processNew() {
+    try { if (fs.lstatSync(filePath).isSymbolicLink()) return; } catch { return; }
+    let stat;
+    try { stat = fs.statSync(filePath); } catch { return; }
+    if (stat.size <= offset) return;
+    const fd = fs.openSync(filePath, "r");
+    try {
+      const buf = Buffer.alloc(stat.size - offset);
+      fs.readSync(fd, buf, 0, buf.length, offset);
+      offset = stat.size;
+      const chunk = buf.toString("utf8");
+      chunk.split("\n").forEach(line => {
+        const obj = parseJsonLine(line);
+        if (obj) callback(obj);
+      });
+    } finally { fs.closeSync(fd); }
+  }
+
+  fs.watchFile(filePath, { interval: interval || 500, persistent: true }, processNew);
+  return () => fs.unwatchFile(filePath, processNew);
+}
+
+function watchJson(filePath, callback, interval) {
+  let lastContent = "";
+  function check() {
+    try {
+      if (fs.lstatSync(filePath).isSymbolicLink()) return;
+      const content = fs.readFileSync(filePath, "utf8");
+      if (content === lastContent) return;
+      lastContent = content;
+      const obj = JSON.parse(content);
+      callback(obj);
+    } catch { /* file missing or malformed — normal */ }
+  }
+  fs.watchFile(filePath, { interval: interval || 2000, persistent: true }, check);
+  check();
+  return () => fs.unwatchFile(filePath, check);
+}
+
+// ── Event Processing ───────────────────────────────────────────────────────
+
+function addRecentEvent(ev) {
+  state.recentEvents.push(ev);
+  if (state.recentEvents.length > MAX_EVENTS) state.recentEvents.shift();
+}
+
+function processEventLine(ev) {
+  const type = ev.event_type || ev.evt;
+
+  if (type === "session_start") {
+    const s = {
+      id: ev.agent_id || ev.sid || "",
+      model: (ev.data && ev.data.model) || ev.model || "",
+      source: (ev.data && ev.data.source) || "",
+      isActive: true,
+      startTs: ev.ts,
+      childAgentIds: new Set(),
+    };
+    state.sessions.set(s.id, s);
+    broadcast("session:start", { id: s.id, model: s.model, source: s.source, ts: ev.ts });
+    addRecentEvent({ type: "spawn", text: "session started", detail: s.id.slice(0, 12), ts: ev.ts });
+  }
+
+  else if (type === "session_end" || type === "session_stop") {
+    const sid = ev.agent_id || ev.sid || "";
+    const s = state.sessions.get(sid);
+    if (s) { s.isActive = false; s.endTs = ev.ts; }
+    broadcast("session:end", { id: sid, ts: ev.ts });
+  }
+
+  else if (type === "subagent_spawn" || type === "agent_spawn") {
+    const id = (ev.data && ev.data.agent_id) || ev.agent_id || ev.id || "";
+    const parentId = (ev.data && ev.data.parent_id) || ev.parent_agent_id || "";
+    const agentType = ev.reasoning || (ev.data && ev.data.agent_type) || "agent";
+    const model = (ev.data && ev.data.model) || "";
+    const a = {
+      id, parentId, type: agentType, model,
+      status: "running", spawnTs: ev.ts, completeTs: null,
+      duration: null, toolCount: 0, lastTool: null, lastToolTs: null,
+      sessionId: ev.sid || parentId,
+    };
+    state.agents.set(id, a);
+    if (model && state.modelCounts[model] !== undefined) state.modelCounts[model]++;
+
+    const session = state.sessions.get(parentId);
+    if (session && session.childAgentIds) session.childAgentIds.add(id);
+
+    broadcast("agent:spawn", { id, parentId, type: agentType, model, spawnTs: ev.ts, sessionId: a.sessionId });
+    addRecentEvent({ type: "spawn", text: `${agentType} spawned`, detail: id.slice(0, 12), ts: ev.ts });
+  }
+
+  else if (type === "subagent_complete" || type === "agent_stop") {
+    const id = (ev.data && ev.data.agent_id) || ev.agent_id || ev.id || "";
+    const a = state.agents.get(id);
+    const status = ev.outcome === "failure" ? "failed" : "done";
+    let duration = null;
+    if (a) {
+      a.status = status;
+      a.completeTs = ev.ts;
+      if (a.spawnTs) duration = (new Date(ev.ts) - new Date(a.spawnTs)) / 1000;
+      a.duration = duration;
+    }
+    broadcast("agent:complete", { id, status, completeTs: ev.ts, duration });
+    addRecentEvent({ type: status === "failed" ? "fail" : "complete",
+      text: `agent ${status}`, detail: `${id.slice(0, 12)}${duration ? " (" + fmtDur(duration) + ")" : ""}`, ts: ev.ts });
+  }
+
+  else if (type === "tool_call" || type === "tool") {
+    state.toolCount++;
+    const agentId = ev.agent_id || "";
+    const tool = ev.tool || ev.reasoning || "";
+    const file = ev.data && (ev.data.file || ev.data.pattern || ev.data.cmd || "");
+    const a = state.agents.get(agentId);
+    if (a) {
+      a.toolCount = (a.toolCount || 0) + 1;
+      a.lastTool = tool;
+      a.lastToolTs = ev.ts;
+      if (!a.toolCounts) a.toolCounts = {};
+      a.toolCounts[tool] = (a.toolCounts[tool] || 0) + 1;
+    }
+    broadcast("agent:tool", { agentId, tool, file, ts: ev.ts });
+  }
+
+  else if (type === "phase_transition") {
+    const phase = ev.phase || ev.reasoning || "";
+    const command = ev.command || "";
+    broadcast("phase:transition", { phase, command, outcome: ev.outcome, ts: ev.ts });
+    addRecentEvent({ type: "phase", text: `Phase: ${phase}`, detail: command, ts: ev.ts });
+  }
+
+  else if (type === "command_invoked") {
+    addRecentEvent({ type: "phase", text: ev.command || "command", detail: ev.reasoning || "", ts: ev.ts });
+  }
+}
+
+function processContextMeter(obj) {
+  state.context = {
+    pct: obj.pct || 0,
+    threshold: obj.threshold || "normal",
+    inputTokens: obj.inputTokens || 0,
+    windowSize: obj.modelWindowSize || 200000,
+    ts: obj.timestamp || new Date().toISOString(),
+  };
+  state.contextHistory.push({ ts: state.context.ts, pct: state.context.pct });
+  if (state.contextHistory.length > MAX_HISTORY) state.contextHistory.shift();
+  broadcast("context:update", state.context);
+}
+
+function processSupervisorState(obj) {
+  state.supervisor = {
+    status: obj.status || "unknown",
+    iter: obj.iter || 0,
+    milestone: obj.milestone || "",
+    workerPid: obj.workerPid || null,
+    elapsed: obj.wallClockElapsedMs || 0,
+  };
+  broadcast("supervisor:update", state.supervisor);
+}
+
+function fmtDur(s) {
+  s = Math.round(s);
+  if (s < 60) return s + "s";
+  if (s < 3600) return Math.floor(s / 60) + "m " + (s % 60) + "s";
+  return Math.floor(s / 3600) + "h " + Math.floor((s % 3600) / 60) + "m";
+}
+
+// ── Bootstrap: Read Existing Data ──────────────────────────────────────────
+
+function bootstrap(projectDir) {
+  const gsdtDir = path.join(projectDir, ".gsd-t");
+
+  // Read existing events
+  const eventsDir = path.join(gsdtDir, "events");
+  try {
+    const files = fs.readdirSync(eventsDir).filter(f => f.endsWith(".jsonl")).sort();
+    for (const f of files) {
+      const lines = fs.readFileSync(path.join(eventsDir, f), "utf8").split("\n");
+      lines.forEach(line => { const obj = parseJsonLine(line); if (obj) processEventLine(obj); });
+    }
+  } catch { /* no events dir */ }
+
+  // Read recent heartbeat files (modified within 2 hours)
+  const cutoff = Date.now() - 2 * 3600 * 1000;
+  try {
+    const hbFiles = fs.readdirSync(gsdtDir).filter(f => f.startsWith("heartbeat-") && f.endsWith(".jsonl"));
+    for (const f of hbFiles) {
+      const fp = path.join(gsdtDir, f);
+      try {
+        const stat = fs.statSync(fp);
+        if (stat.mtimeMs < cutoff) continue;
+        const lines = fs.readFileSync(fp, "utf8").split("\n");
+        lines.forEach(line => { const obj = parseJsonLine(line); if (obj) processEventLine(obj); });
+      } catch { /* skip */ }
+    }
+  } catch { /* no heartbeat files */ }
+
+  // Read context meter
+  const cmPath = path.join(gsdtDir, ".context-meter-state.json");
+  try {
+    const obj = JSON.parse(fs.readFileSync(cmPath, "utf8"));
+    processContextMeter(obj);
+  } catch { /* not present */ }
+
+  // Read supervisor state
+  const supPath = path.join(gsdtDir, ".unattended", "state.json");
+  try {
+    const obj = JSON.parse(fs.readFileSync(supPath, "utf8"));
+    processSupervisorState(obj);
+  } catch { /* not running */ }
+}
+
+// ── Start Tailing ──────────────────────────────────────────────────────────
+
+const unwatchers = [];
+
+function startTailing(projectDir) {
+  const gsdtDir = path.join(projectDir, ".gsd-t");
+  const eventsDir = path.join(gsdtDir, "events");
+
+  // Tail today's event file
+  const today = new Date().toISOString().slice(0, 10);
+  const evFile = path.join(eventsDir, today + ".jsonl");
+  try { fs.accessSync(eventsDir); } catch { try { fs.mkdirSync(eventsDir, { recursive: true }); } catch {} }
+  unwatchers.push(tailFile(evFile, processEventLine));
+
+  // Watch for new event files (date rollover)
+  try {
+    const watcher = fs.watch(eventsDir, (eventType, filename) => {
+      if (filename && filename.endsWith(".jsonl") && filename > today + ".jsonl") {
+        unwatchers.push(tailFile(path.join(eventsDir, filename), processEventLine));
+      }
+    });
+    unwatchers.push(() => watcher.close());
+  } catch { /* events dir may not exist */ }
+
+  // Tail active heartbeat files
+  try {
+    const cutoff = Date.now() - 2 * 3600 * 1000;
+    const hbFiles = fs.readdirSync(gsdtDir).filter(f => f.startsWith("heartbeat-") && f.endsWith(".jsonl"));
+    for (const f of hbFiles) {
+      const fp = path.join(gsdtDir, f);
+      try { if (fs.statSync(fp).mtimeMs >= cutoff) unwatchers.push(tailFile(fp, processEventLine, 500)); } catch {}
+    }
+  } catch {}
+
+  // Watch for new heartbeat files
+  try {
+    const watcher = fs.watch(gsdtDir, (eventType, filename) => {
+      if (filename && filename.startsWith("heartbeat-") && filename.endsWith(".jsonl")) {
+        unwatchers.push(tailFile(path.join(gsdtDir, filename), processEventLine, 500));
+      }
+    });
+    unwatchers.push(() => watcher.close());
+  } catch {}
+
+  // Watch context meter
+  unwatchers.push(watchJson(path.join(gsdtDir, ".context-meter-state.json"), processContextMeter, 2000));
+
+  // Watch supervisor state
+  unwatchers.push(watchJson(path.join(gsdtDir, ".unattended", "state.json"), processSupervisorState, 5000));
+}
+
+// ── HTTP Server ────────────────────────────────────────────────────────────
+
+function createServer(projectDir, port) {
+  const htmlPath = path.join(__dirname, "gsd-t-agent-dashboard.html");
+
+  const server = http.createServer((req, res) => {
+    const url = req.url.split("?")[0];
+
+    if (url === "/" || url === "/index.html") {
+      fs.readFile(htmlPath, (err, data) => {
+        if (err) { res.writeHead(404); res.end("Not found"); return; }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(data);
+      });
+    }
+
+    else if (url === "/stream") {
+      res.writeHead(200, SSE_HEADERS);
+      clients.add(res);
+      sendSnapshot(res);
+
+      const keepalive = setInterval(() => {
+        try { res.write(": keepalive\n\n"); } catch { clearInterval(keepalive); clients.delete(res); }
+      }, KEEPALIVE_MS);
+
+      req.on("close", () => { clearInterval(keepalive); clients.delete(res); });
+    }
+
+    else if (url === "/snapshot") {
+      const snapshot = {
+        agents: [...state.agents.values()],
+        sessions: [...state.sessions.values()].map(s => ({ ...s, childAgentIds: [...(s.childAgentIds || [])] })),
+        context: state.context,
+        supervisor: state.supervisor,
+        events: state.recentEvents.slice(-100),
+        contextHistory: state.contextHistory,
+        modelCounts: { ...state.modelCounts },
+        toolCount: state.toolCount,
+      };
+      res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+      res.end(JSON.stringify(snapshot));
+    }
+
+    else if (url === "/ping") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", port, agents: state.agents.size, sessions: state.sessions.size }));
+    }
+
+    else if (url === "/stop") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "stopping" }));
+      cleanup();
+      server.close();
+      process.exit(0);
+    }
+
+    else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+
+  server.listen(port, () => {
+    console.log(`[agent-dashboard] listening on http://localhost:${port}`);
+    console.log(`[agent-dashboard] project: ${projectDir}`);
+    console.log(`[agent-dashboard] agents: ${state.agents.size}, sessions: ${state.sessions.size}`);
+  });
+
+  return server;
+}
+
+function cleanup() {
+  for (const fn of unwatchers) {
+    try { if (typeof fn === "function") fn(); } catch {}
+  }
+  unwatchers.length = 0;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+const projectDir = process.argv[2] || process.cwd();
+const port = parseInt(process.argv[3] || process.env.GSD_T_AGENT_DASHBOARD_PORT || DEFAULT_PORT, 10);
+
+bootstrap(projectDir);
+startTailing(projectDir);
+createServer(projectDir, port);
+
+process.on("SIGINT", () => { cleanup(); process.exit(0); });
+process.on("SIGTERM", () => { cleanup(); process.exit(0); });