@triflux/remote 10.1.0 → 10.26.0

package/hub/team/tui-synapse.mjs

@@ -0,0 +1,223 @@
+// hub/team/tui-synapse.mjs — Synapse 실시간 관제 (Phase 3)
+// HTTP polling 기반 이벤트 수신 + 메트릭 수집 + 스파크라인 렌더링
+
+import { color, dim, MOCHA } from "./ansi.mjs";
+import { sparkline } from "./tui-widgets.mjs";
+
+const DEFAULT_SYNAPSE_BASE_URL = "http://127.0.0.1:27888";
+const DEFAULT_POLL_INTERVAL_MS = 2000;
+const MAX_METRIC_SAMPLES = 30;
+
+// ── SynapseEventStream ────────────────────────────────────────────────────
+/**
+ * Synapse 서버로부터 이벤트를 polling으로 수신
+ * @param {object} [opts]
+ * @param {string} [opts.baseUrl] - Synapse 서버 URL
+ * @param {number} [opts.pollIntervalMs] - polling 간격
+ * @param {function} [opts.fetchImpl] - fetch 구현 (테스트용)
+ * @param {function} [opts.onEvent] - 이벤트 콜백
+ * @param {function} [opts.onError] - 에러 콜백
+ */
+export function createSynapseEventStream(opts = {}) {
+  const {
+    baseUrl = DEFAULT_SYNAPSE_BASE_URL,
+    pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
+    onEvent,
+    onError,
+  } = opts;
+
+  const fetchImpl = opts.fetchImpl || globalThis.fetch?.bind(globalThis);
+  let timer = null;
+  let lastEventId = 0;
+  let running = false;
+
+  async function poll(force = false) {
+    if (!fetchImpl || (!running && !force)) return;
+    try {
+      const url = new URL("/synapse/events", baseUrl);
+      url.searchParams.set("since", String(lastEventId));
+      const res = await fetchImpl(url.toString(), {
+        method: "GET",
+        headers: { accept: "application/json" },
+        signal: AbortSignal.timeout?.(5000),
+      });
+      if (!res.ok) return;
+      const data = await res.json();
+      if (Array.isArray(data.events)) {
+        for (const event of data.events) {
+          if (event.id > lastEventId) lastEventId = event.id;
+          onEvent?.(event);
+        }
+      }
+    } catch (err) {
+      onError?.(err);
+    }
+  }
+
+  return {
+    start() {
+      if (running) return;
+      running = true;
+      // 즉시 첫 poll + 주기적 반복
+      poll();
+      timer = setInterval(poll, pollIntervalMs);
+      if (timer.unref) timer.unref();
+    },
+
+    stop() {
+      running = false;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    },
+
+    get isRunning() {
+      return running;
+    },
+
+    /** 테스트/수동 용: 즉시 poll 실행 (running 상태 무관) */
+    async pollOnce() {
+      await poll(true);
+    },
+
+    reset() {
+      lastEventId = 0;
+    },
+  };
+}
+
+// ── MetricsCollector ──────────────────────────────────────────────────────
+/**
+ * Synapse 이벤트에서 메트릭(토큰, 지연시간, 성공률)을 수집
+ */
+export function createMetricsCollector(opts = {}) {
+  const { maxSamples = MAX_METRIC_SAMPLES } = opts;
+
+  const metrics = {
+    tokenRates: [], // 초당 토큰 소비율
+    latencies: [], // 요청 지연시간 (ms)
+    successRates: [], // 성공률 (0-1)
+    eventCount: 0,
+    lastEventAt: 0,
+  };
+
+  function pushSample(arr, value) {
+    arr.push(value);
+    if (arr.length > maxSamples) arr.shift();
+  }
+
+  return {
+    /** Synapse 이벤트를 처리하여 메트릭 갱신 */
+    ingest(event) {
+      if (!event || typeof event !== "object") return;
+      metrics.eventCount++;
+      metrics.lastEventAt = Date.now();
+
+      // 토큰 소비율
+      if (typeof event.tokens === "number" && event.tokens > 0) {
+        const elapsed = event.elapsed || 1;
+        pushSample(metrics.tokenRates, event.tokens / elapsed);
+      }
+
+      // 지연시간
+      if (typeof event.latencyMs === "number") {
+        pushSample(metrics.latencies, event.latencyMs);
+      }
+
+      // 성공률 (이벤트별 ok/fail)
+      if (event.status) {
+        const ok =
+          event.status === "ok" || event.status === "completed" ? 1 : 0;
+        pushSample(metrics.successRates, ok);
+      }
+    },
+
+    /** 현재 메트릭 스냅샷 반환 */
+    snapshot() {
+      const avgLatency =
+        metrics.latencies.length > 0
+          ? metrics.latencies.reduce((a, b) => a + b, 0) /
+            metrics.latencies.length
+          : 0;
+      const avgSuccessRate =
+        metrics.successRates.length > 0
+          ? metrics.successRates.reduce((a, b) => a + b, 0) /
+            metrics.successRates.length
+          : 1;
+      const lastTokenRate =
+        metrics.tokenRates.length > 0
+          ? metrics.tokenRates[metrics.tokenRates.length - 1]
+          : 0;
+
+      return {
+        tokenRates: [...metrics.tokenRates],
+        latencies: [...metrics.latencies],
+        successRates: [...metrics.successRates],
+        avgLatency: Math.round(avgLatency),
+        avgSuccessRate: Math.round(avgSuccessRate * 100),
+        lastTokenRate: Math.round(lastTokenRate),
+        eventCount: metrics.eventCount,
+        lastEventAt: metrics.lastEventAt,
+      };
+    },
+
+    reset() {
+      metrics.tokenRates.length = 0;
+      metrics.latencies.length = 0;
+      metrics.successRates.length = 0;
+      metrics.eventCount = 0;
+      metrics.lastEventAt = 0;
+    },
+  };
+}
+
+// ── Tier1 메트릭 렌더러 ───────────────────────────────────────────────────
+/**
+ * Synapse 메트릭을 Tier1에 표시할 한 줄 문자열로 렌더링
+ * @param {object} snapshot - MetricsCollector.snapshot() 결과
+ * @param {number} [width=60] - 최대 표시 폭
+ * @returns {string} 렌더링된 메트릭 행
+ */
+export function renderMetricsTier1(snapshot, width = 60) {
+  if (!snapshot || snapshot.eventCount === 0) {
+    return dim("synapse: waiting for events…");
+  }
+
+  const parts = [];
+
+  // 토큰 스파크라인
+  if (snapshot.tokenRates.length > 0) {
+    const spark = sparkline(snapshot.tokenRates, 8, MOCHA.executing);
+    parts.push(
+      `tok/s ${spark} ${color(String(snapshot.lastTokenRate), MOCHA.executing)}`,
+    );
+  }
+
+  // 지연시간
+  if (snapshot.latencies.length > 0) {
+    const latColor =
+      snapshot.avgLatency > 1000
+        ? MOCHA.fail
+        : snapshot.avgLatency > 500
+          ? MOCHA.partial
+          : MOCHA.ok;
+    parts.push(`lat ${color(`${snapshot.avgLatency}ms`, latColor)}`);
+  }
+
+  // 성공률
+  if (snapshot.successRates.length > 0) {
+    const srColor =
+      snapshot.avgSuccessRate < 80
+        ? MOCHA.fail
+        : snapshot.avgSuccessRate < 95
+          ? MOCHA.partial
+          : MOCHA.ok;
+    parts.push(`ok ${color(`${snapshot.avgSuccessRate}%`, srColor)}`);
+  }
+
+  // 이벤트 카운트
+  parts.push(dim(`ev:${snapshot.eventCount}`));
+
+  return parts.join(dim(" │ "));
+}

package/hub/team/tui-viewer.mjs

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
+
 // hub/team/tui-viewer.mjs — worker state aggregator v5
 // psmux capture-pane 기반 워커 상태 집계 + TUI 렌더링
 // data ingest: ~2Hz (500ms), render: 8-12FPS (별도 루프)
 
-import { existsSync, readFileSync, statSync } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { join } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { createLogDashboard } from "./tui.mjs";
-import { createLiteDashboard } from "./tui-lite.mjs";
+import { join } from "node:path";
+import { formatPsmuxInstallGuidance } from "../../scripts/lib/psmux-info.mjs";
 import { openHeadlessDashboardTarget } from "./dashboard-open.mjs";
 import { processHandoff } from "./handoff.mjs";
-
+import { createLogDashboard } from "./tui.mjs";
+import { createLiteDashboard } from "./tui-lite.mjs";
 
 // ── CLI 인자 파싱 ──
 const args = process.argv.slice(2);
@@ -20,9 +21,9 @@ function argVal(flag) {
   return idx >= 0 ? args[idx + 1] : null;
 }
 
-const SESSION    = argVal("--session");
+const SESSION = argVal("--session");
 const RESULT_DIR = argVal("--result-dir") ?? join(tmpdir(), "tfx-headless");
-const LAYOUT     = argVal("--layout") ?? "single";
+const LAYOUT = argVal("--layout") ?? "single";
 
 if (!SESSION) {
   process.stderr.write(
@@ -35,7 +36,7 @@ try {
   execFileSync("psmux", ["--version"], { encoding: "utf8", timeout: 2000 });
 } catch {
   process.stderr.write(
-    "ERROR: psmux 미설치. 설치: winget install marlocarlo.psmux (또는 npm i -g psmux)\n",
+    `ERROR: psmux 미설치. 설치 방법:\n${formatPsmuxInstallGuidance("  ")}\n`,
   );
   process.exit(1);
 }
@@ -48,20 +49,22 @@ const MAX_BODY_BYTES = 10240;
 // forceTTY 시 alternate screen이 WT pane에서 렌더링 안 되는 문제 → append-only 유지
 const tuiFactory = LAYOUT === "lite" ? createLiteDashboard : createLogDashboard;
 const tui = tuiFactory({
-  refreshMs: 0,          // render 루프를 직접 제어
+  refreshMs: 0, // render 루프를 직접 제어
   stream: process.stdout,
   input: process.stdin,
   columns: process.stdout.columns || parseInt(process.env.COLUMNS, 10) || 120,
   layout: LAYOUT,
-  onOpenSelectedWorker: (workerName) => openHeadlessDashboardTarget(SESSION, {
-    worker: workerName,
-    openAll: false,
-    cwd: process.cwd(),
-  }),
-  onOpenAllWorkers: () => openHeadlessDashboardTarget(SESSION, {
-    openAll: true,
-    cwd: process.cwd(),
-  }),
+  onOpenSelectedWorker: (workerName) =>
+    openHeadlessDashboardTarget(SESSION, {
+      worker: workerName,
+      openAll: false,
+      cwd: process.cwd(),
+    }),
+  onOpenAllWorkers: () =>
+    openHeadlessDashboardTarget(SESSION, {
+      openAll: true,
+      cwd: process.cwd(),
+    }),
 });
 const startTime = Date.now();
 tui.setStartTime(startTime);
@@ -72,6 +75,9 @@ const INTERNAL_PATTERNS = [
   /\.err\b/,
   /completion[-_]token/i,
   /^---\s*HANDOFF\s*---$/i,
+  /Get-Content/,
+  /-color\s+never/,
+  /AppData[\\/]Local[\\/]Temp[\\/]tfx-headless/,
 ];
 
 function isInternalLine(line) {
@@ -126,10 +132,10 @@ function extractFindings(lines, verdict = "") {
 
 // ── Phase 가중치 진행률 (Plan=10%, Research=30%, Exec=50%, Verify=10%) ──
 const PHASE_WEIGHTS = {
-  plan:    0.10,
-  research:0.40,   // plan + research
-  exec:    0.90,   // plan + research + exec
-  verify:  1.00,
+  plan: 0.1,
+  research: 0.4, // plan + research
+  exec: 0.9, // plan + research + exec
+  verify: 1.0,
 };
 
 function estimateProgress(lines, context = {}) {
@@ -138,9 +144,11 @@ function estimateProgress(lines, context = {}) {
   const text = lines.join("\n").toLowerCase();
   let phase = "plan";
 
-  if (/verify|assert|test|check|confirm/.test(text))       phase = "verify";
-  else if (/edit|patch|implement|write|update|fix|refactor/.test(text)) phase = "exec";
-  else if (/search|read|inspect|analy|review|research/.test(text))     phase = "research";
+  if (/verify|assert|test|check|confirm/.test(text)) phase = "verify";
+  else if (/edit|patch|implement|write|update|fix|refactor/.test(text))
+    phase = "exec";
+  else if (/search|read|inspect|analy|review|research/.test(text))
+    phase = "research";
 
   let ratio = PHASE_WEIGHTS[phase];
 
@@ -161,7 +169,13 @@ function listPanes() {
   try {
     const out = execFileSync(
       "psmux",
-      ["list-panes", "-t", SESSION, "-F", "#{pane_index}:#{pane_title}:#{pane_pid}"],
+      [
+        "list-panes",
+        "-t",
+        SESSION,
+        "-F",
+        "#{pane_index}:#{pane_title}:#{pane_pid}",
+      ],
       { encoding: "utf8", timeout: 2000 },
     );
     return out
@@ -245,7 +259,7 @@ function splitHandoff(handoff) {
 }
 
 // ── 상태 집계 저장소 ──
-const workerState = new Map();   // paneName → 내부 상태
+const workerState = new Map(); // paneName → 내부 상태
 let emptyPollCount = 0;
 
 // ── data ingest (4Hz = 250ms) ──
@@ -260,13 +274,21 @@ function ingest() {
       clearInterval(ingestTimer);
       clearInterval(renderTimer);
       tui.render();
-      process.stdout.write("\n\x1b[38;5;245m  세션 종료됨 — 아무 키나 누르면 닫힘\x1b[0m");
+      process.stdout.write(
+        "\n\x1b[38;5;245m  세션 종료됨 — 아무 키나 누르면 닫힘\x1b[0m",
+      );
       if (process.stdin.isTTY) {
         process.stdin.setRawMode(true);
         process.stdin.resume();
-        process.stdin.once("data", () => { cleanup(); process.exit(0); });
+        process.stdin.once("data", () => {
+          cleanup();
+          process.exit(0);
+        });
       } else {
-        setTimeout(() => { cleanup(); process.exit(0); }, 30000);
+        setTimeout(() => {
+          cleanup();
+          process.exit(0);
+        }, 30000);
       }
       return;
     }
@@ -287,8 +309,10 @@ function ingest() {
 
     // CLI 타입 감지
     let cli = "codex";
-    if (pane.title.includes("gemini") || pane.title.includes("🔵")) cli = "gemini";
-    else if (pane.title.includes("claude") || pane.title.includes("🟠")) cli = "claude";
+    if (pane.title.includes("gemini") || pane.title.includes("🔵"))
+      cli = "gemini";
+    else if (pane.title.includes("claude") || pane.title.includes("🟠"))
+      cli = "claude";
     ws.title = pane.title;
     ws.cli = cli;
 
@@ -334,7 +358,11 @@ function ingest() {
 
     const resultFile = join(RESULT_DIR, `${SESSION}-${paneName}.txt`);
     let resultSize = 0;
-    try { resultSize = statSync(resultFile).size; } catch { /* missing */ }
+    try {
+      resultSize = statSync(resultFile).size;
+    } catch {
+      /* missing */
+    }
 
     const shellReturned = /^(PS\s|>|\$)\s*/.test(lastLine) && lines.length > 2;
     const tokens = extractTokenLabel(snapshot);
@@ -346,7 +374,9 @@ function ingest() {
         : snapshot;
       const rLines = toLines(resultContent);
       const verdict = extractFindings(rLines).at(-1) || lastLine || "completed";
-      const handoffStatus = /fail|error|exception/i.test(rLines.join("\n")) ? "failed" : "ok";
+      const handoffStatus = /fail|error|exception/i.test(rLines.join("\n"))
+        ? "failed"
+        : "ok";
       const handoff = {
         status: handoffStatus,
         lead_action: handoffStatus === "failed" ? "retry" : "accept",
@@ -378,11 +408,22 @@ function ingest() {
     }
 
     // 진행 중
-    const progress = estimateProgress(lines, { tokens, resultSize, shellReturned, done: false });
+    const progress = estimateProgress(lines, {
+      tokens,
+      resultSize,
+      shellReturned,
+      done: false,
+    });
     const verdict = lastLine;
 
-    ws.raw_body = raw_body.length > MAX_BODY_BYTES ? raw_body.slice(-MAX_BODY_BYTES) : raw_body;
-    ws.filtered_body = filtered_body.length > MAX_BODY_BYTES ? filtered_body.slice(-MAX_BODY_BYTES) : filtered_body;
+    ws.raw_body =
+      raw_body.length > MAX_BODY_BYTES
+        ? raw_body.slice(-MAX_BODY_BYTES)
+        : raw_body;
+    ws.filtered_body =
+      filtered_body.length > MAX_BODY_BYTES
+        ? filtered_body.slice(-MAX_BODY_BYTES)
+        : filtered_body;
     ws.verdict = verdict;
     ws.findings = extractFindings(lines, lastLine);
     ws.progress = progress;
@@ -406,16 +447,18 @@ function ingest() {
 function pushToTui(paneName, cli, paneTitle, update) {
   // _leadAction은 tui에 노출하지 않음 (내부용)
   const { _leadAction: _ignored, ...safeUpdate } = update;
-  // pane title에서 실제 역할만 추출: "⚪ codex (executor)" → "executor"
-  const roleMatch = paneTitle.match(/\(([^)]+)\)$/);
-  const role = roleMatch ? roleMatch[1] : "";
-  tui.updateWorker(paneName, { cli, role, ...safeUpdate });
+  // pane title의 괄호 값은 UI 라벨이며 role 의미값으로 승격하지 않는다.
+  const labelMatch = paneTitle.match(/\(([^)]+)\)$/);
+  const displayName = labelMatch ? labelMatch[1] : paneName;
+  tui.updateWorker(paneName, { cli, displayName, role: "", ...safeUpdate });
 }
 
 // ── render 루프 (8-12FPS ≈ 100ms) ──
 let renderTimer = null;
 function startRender() {
-  renderTimer = setInterval(() => { tui.render(); }, 100);
+  renderTimer = setInterval(() => {
+    tui.render();
+  }, 100);
   if (renderTimer.unref) renderTimer.unref();
 }
 
@@ -426,13 +469,21 @@ const doneCheck = setInterval(() => {
     clearInterval(doneCheck);
     clearInterval(ingestTimer);
     clearInterval(renderTimer);
-    process.stdout.write("\n\x1b[38;5;245m  전체 완료 — 아무 키나 누르면 닫힘\x1b[0m");
+    process.stdout.write(
+      "\n\x1b[38;5;245m  전체 완료 — 아무 키나 누르면 닫힘\x1b[0m",
+    );
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(true);
       process.stdin.resume();
-      process.stdin.once("data", () => { cleanup(); process.exit(0); });
+      process.stdin.once("data", () => {
+        cleanup();
+        process.exit(0);
+      });
     } else {
-      setTimeout(() => { cleanup(); process.exit(0); }, 30000);
+      setTimeout(() => {
+        cleanup();
+        process.exit(0);
+      }, 30000);
     }
   }
 }, 2000);
@@ -452,11 +503,20 @@ function cleanup() {
 
 // ── 진입점 ──
 tui.render();
-const ingestTimer = setInterval(ingest, 500);   // 2Hz
+const ingestTimer = setInterval(ingest, 500); // 2Hz
 startRender();
 
 // 타임아웃 (10분)
-setTimeout(() => { cleanup(); process.exit(0); }, 10 * 60 * 1000);
+setTimeout(
+  () => {
+    cleanup();
+    process.exit(0);
+  },
+  10 * 60 * 1000,
+);
 
 // Ctrl-C
-process.on("SIGINT", () => { cleanup(); process.exit(0); });
+process.on("SIGINT", () => {
+  cleanup();
+  process.exit(0);
+});