triflux 8.0.0 → 8.2.2

package/hub/team/tui-viewer.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-// hub/team/tui-viewer.mjs — psmux pane용 append-only 로그 뷰어 v3
-// 같은 psmux 세션의 워커 pane을 capture-pane으로 모니터링한다.
+// 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";
@@ -8,173 +9,436 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { createLogDashboard } from "./tui.mjs";
 import { processHandoff } from "./handoff.mjs";
+import { statusBadge } from "./ansi.mjs";
 
+
+// ── CLI 인자 파싱 ──
 const args = process.argv.slice(2);
-const sessionIdx = args.indexOf("--session");
-const resultDirIdx = args.indexOf("--result-dir");
-const SESSION = sessionIdx >= 0 ? args[sessionIdx + 1] : null;
-const RESULT_DIR = resultDirIdx >= 0
-  ? args[resultDirIdx + 1]
-  : join(tmpdir(), "tfx-headless");
+function argVal(flag) {
+  const idx = args.indexOf(flag);
+  return idx >= 0 ? args[idx + 1] : null;
+}
+
+const SESSION    = argVal("--session");
+const RESULT_DIR = argVal("--result-dir") ?? join(tmpdir(), "tfx-headless");
+const LAYOUT     = argVal("--layout") ?? "single";
 
 if (!SESSION) {
-  process.stderr.write("Usage: node tui-viewer.mjs --session <name>\n");
+  process.stderr.write(
+    "Usage: node tui-viewer.mjs --session <name> [--result-dir <dir>] [--layout <name>]\n",
+  );
   process.exit(1);
 }
 
-// ── psmux 존재 확인 ──
 try {
   execFileSync("psmux", ["--version"], { encoding: "utf8", timeout: 2000 });
 } catch {
-  process.stderr.write("ERROR: psmux not found or not executable. Install psmux before running tui-viewer.\n");
+  process.stderr.write(
+    "ERROR: psmux not found or not executable. Install psmux before running tui-viewer.\n",
+  );
   process.exit(1);
 }
 
-const tui = createLogDashboard({ refreshMs: 0 });
+// ── 메모리 보호 상수 ──
+const MAX_BODY_BYTES = 10240;
+
+// ── TUI 초기화 ──
+// WT pane에서 spawn 시 process.stdout.isTTY=false일 수 있음
+// forceTTY 시 alternate screen이 WT pane에서 렌더링 안 되는 문제 → append-only 유지
+const tui = createLogDashboard({
+  refreshMs: 0,          // render 루프를 직접 제어
+  stream: process.stdout,
+  input: process.stdin,
+  columns: process.stdout.columns || parseInt(process.env.COLUMNS, 10) || 120,
+  layout: LAYOUT,
+});
 const startTime = Date.now();
 tui.setStartTime(startTime);
 
-// ── psmux pane 목록 조회 ──
+// ── 내부 raw data 누출 방지 패턴 ──
+const INTERNAL_PATTERNS = [
+  /\$trifluxExit/,
+  /\.err\b/,
+  /completion[-_]token/i,
+  /^---\s*HANDOFF\s*---$/i,
+];
+
+function isInternalLine(line) {
+  return INTERNAL_PATTERNS.some((re) => re.test(line));
+}
+
+// ── 코드블록 필터링 → filtered_body 생성 ──
+function filterCodeBlocks(text) {
+  return String(text || "")
+    .replace(/\r/g, "")
+    .replace(/```[\s\S]*?(?:```|$)/gm, "\n")
+    .replace(/^\s*```.*$/gm, "")
+    .trim();
+}
+
+function toFilteredBody(text) {
+  return filterCodeBlocks(text)
+    .split("\n")
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .filter((l) => !isInternalLine(l))
+    .filter((l) => !/^(PS\s|>|\$)\s*/.test(l))
+    .join("\n");
+}
+
+function toLines(text) {
+  return toFilteredBody(text).split("\n").filter(Boolean);
+}
+
+// ── 토큰 라벨 추출 ──
+function extractTokenLabel(text) {
+  const m = String(text || "").match(
+    /(\d+(?:[.,]\d+)?\s*[kKmM]?)(?=\s*tokens?\s+used|\s*tokens?\b)/i,
+  );
+  return m ? m[1].replace(/\s+/g, "").toLowerCase() : "";
+}
+
+// ── findings 추출 ──
+function extractFindings(lines, verdict = "") {
+  return lines
+    .map((l) => l.replace(/^verdict\s*:\s*/i, "").trim())
+    .filter(Boolean)
+    .filter(
+      (l) =>
+        !/^(status|lead_action|confidence|files_changed|detail|risk|error_stage|retryable|partial_output)\s*:/i.test(
+          l,
+        ),
+    )
+    .filter((l) => l !== verdict)
+    .slice(-2);
+}
+
+// ── 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,
+};
+
+function estimateProgress(lines, context = {}) {
+  if (context.done) return 1;
+
+  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";
+
+  let ratio = PHASE_WEIGHTS[phase];
+
+  // 라인 수 기반 보정
+  if (lines.length < 2) ratio = Math.min(ratio, 0.12);
+
+  // 토큰 발생 시 최소 88%
+  if (context.tokens) ratio = Math.max(ratio, 0.88);
+
+  // 결과 파일 존재 or 쉘 복귀 → 완료로 간주
+  if (context.resultSize > 10 || context.shellReturned) return 1;
+
+  return Math.min(0.97, ratio);
+}
+
+// ── psmux 래퍼 ──
 function listPanes() {
   try {
-    const out = execFileSync("psmux", [
-      "list-panes", "-t", SESSION, "-F",
-      "#{pane_index}:#{pane_title}:#{pane_pid}",
-    ], { encoding: "utf8", timeout: 2000 });
-    return out.trim().split("\n").filter(Boolean).map(line => {
-      const [index, title, pid] = line.split(":");
-      return { index: parseInt(index, 10), title: title || "", pid };
-    });
+    const out = execFileSync(
+      "psmux",
+      ["list-panes", "-t", SESSION, "-F", "#{pane_index}:#{pane_title}:#{pane_pid}"],
+      { encoding: "utf8", timeout: 2000 },
+    );
+    return out
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => {
+        const [index, title, pid] = line.split(":");
+        return { index: parseInt(index, 10), title: title || "", pid };
+      });
   } catch {
-    // psmux 미설치 또는 세션 없음 — 빈 목록 반환
     return [];
   }
 }
 
-// ── pane 캡처 ──
-function capturePane(paneIdx, lines = 5) {
+function capturePane(paneIdx, lines = 20) {
   try {
-    return execFileSync("psmux", [
-      "capture-pane", "-t", `${SESSION}:0.${paneIdx}`, "-p",
-    ], { encoding: "utf8", timeout: 2000 }).trim().split("\n").slice(-lines).join("\n");
+    return execFileSync(
+      "psmux",
+      ["capture-pane", "-t", `${SESSION}:0.${paneIdx}`, "-p"],
+      { encoding: "utf8", timeout: 2000 },
+    )
+      .trim()
+      .split("\n")
+      .slice(-lines)
+      .join("\n");
   } catch {
-    // pane 캡처 실패 (pane 종료 또는 세션 소멸) — 빈 문자열 반환
     return "";
   }
 }
 
-// ── result 파일에서 handoff 파싱 ──
 function checkResultFile(paneName) {
   const resultFile = join(RESULT_DIR, `${SESSION}-${paneName}.txt`);
   if (!existsSync(resultFile)) return null;
   try {
     const content = readFileSync(resultFile, "utf8");
-    if (content.trim().length === 0) return null;
-    return processHandoff(content, { exitCode: 0, resultFile });
+    if (!content.trim()) return null;
+    return {
+      resultFile,
+      content,
+      processed: processHandoff(content, { exitCode: 0, resultFile }),
+    };
   } catch {
-    // result 파일 파싱 실패 — null 반환하여 진행 중으로 처리
     return null;
   }
 }
 
-// ── 메인 폴링 ──
-const POLL_MS = 1000;
-const workerState = new Map(); // paneName → { paneIdx, done }
+// ── 워커 상태 모델 ──
+// 각 워커는 다음 필드를 가짐:
+//   raw_body      — capture-pane 원시 텍스트
+//   filtered_body — 코드블록 + 내부 패턴 제거된 텍스트
+//   verdict       — 한 줄 결론
+//   findings[]    — 주목할 라인 (최대 2)
+//   handoff{}     — { status, lead_action, verdict, ... }
+//   progress      — 0~1
+//   activityAt    — 마지막 변경 타임스탬프
+//   done          — boolean
+function makeWorkerState(paneIdx) {
+  return {
+    paneIdx,
+    done: false,
+    raw_body: "",
+    filtered_body: "",
+    verdict: "",
+    findings: [],
+    handoff: null,
+    progress: 0,
+    activityAt: Date.now(),
+  };
+}
+
+// HANDOFF status / lead_action 분리
+function splitHandoff(handoff) {
+  if (!handoff) return { status: "pending", lead_action: null };
+  return {
+    status: handoff.status || "pending",
+    lead_action: handoff.lead_action || null,
+  };
+}
+
+// ── 상태 집계 저장소 ──
+const workerState = new Map();   // paneName → 내부 상태
 let emptyPollCount = 0;
 
-function poll() {
+// ── data ingest (4Hz = 250ms) ──
+function ingest() {
   const panes = listPanes();
 
-  // 세션 사망 감지: 워커 pane이 없는 상태가 지속되면 자동 종료
-  if (!panes.some(p => p.index !== 0)) {
+  if (!panes.some((p) => p.index !== 0)) {
     emptyPollCount++;
     const threshold = workerState.size === 0 ? 15 : 10;
     if (emptyPollCount >= threshold) {
-      tui.close(); clearInterval(timer); clearInterval(doneCheck); process.exit(0);
+      // 세션 종료 후에도 최종 결과 유지 — 키 입력 시 종료
+      clearInterval(ingestTimer);
+      clearInterval(renderTimer);
+      tui.render();
+      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); });
+      } else {
+        setTimeout(() => { cleanup(); process.exit(0); }, 30000);
+      }
+      return;
     }
-  } else {
-    emptyPollCount = 0;
+    return;
   }
+  emptyPollCount = 0;
 
-  // pane 0 = 대시보드 (자기 자신), pane 1+ = 워커
   for (const pane of panes) {
-    if (pane.index === 0) continue; // 자기 자신 건너뜀
-    const paneName = `worker-${pane.index}`;
-    const existing = workerState.get(paneName);
+    if (pane.index === 0) continue;
 
-    if (existing?.done) continue;
+    const paneName = `worker-${pane.index}`;
+    let ws = workerState.get(paneName);
+    if (!ws) {
+      ws = makeWorkerState(pane.index);
+      workerState.set(paneName, ws);
+    }
+    if (ws.done) continue;
 
-    // CLI 타입 추정 (pane title에서)
+    // 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";
 
-    // result 파일 확인 (완료 여부)
-    const handoffResult = checkResultFile(paneName);
-    if (handoffResult && !handoffResult.fallback) {
-      workerState.set(paneName, { paneIdx: pane.index, done: true });
-      tui.updateWorker(paneName, {
-        cli,
-        role: pane.title,
-        status: handoffResult.handoff.status === "failed" ? "failed" : "completed",
-        handoff: handoffResult.handoff,
+    const resultData = checkResultFile(paneName);
+    if (resultData?.processed && !resultData.processed.fallback) {
+      // 결과 파일 처리 완료
+      const raw = resultData.content;
+      const filtered = toFilteredBody(raw);
+      const lines = filtered.split("\n").filter(Boolean);
+      const handoff = resultData.processed.handoff;
+      const verdict = handoff.verdict || "completed";
+
+      ws.done = true;
+      ws.raw_body = raw;
+      ws.filtered_body = filtered;
+      ws.verdict = verdict;
+      ws.findings = extractFindings(lines, verdict);
+      ws.handoff = handoff;
+      ws.progress = 1;
+      ws.activityAt = Date.now();
+
+      const { status, lead_action } = splitHandoff(handoff);
+      pushToTui(paneName, cli, pane.title, {
+        status: status === "failed" ? "failed" : "completed",
+        handoff,
+        summary: verdict,
+        detail: filtered,
+        findings: ws.findings,
+        tokens: extractTokenLabel(raw),
+        progress: 1,
         elapsed: Math.round((Date.now() - startTime) / 1000),
+        _leadAction: lead_action,
       });
       continue;
     }
 
-    // 진행 중 — pane 캡처로 스냅샷
-    const snapshot = capturePane(pane.index, 5);
-    const lines = snapshot.split("\n").filter(l => l.trim());
-    const lastLine = lines.pop() || "";
-
-    if (!existing) {
-      workerState.set(paneName, { paneIdx: pane.index, done: false });
-    }
+    // 스냅샷 기반 진행 중 상태
+    const snapshot = capturePane(pane.index, 20);
+    const raw_body = snapshot;
+    const filtered_body = toFilteredBody(snapshot);
+    const lines = filtered_body.split("\n").filter(Boolean);
+    const lastLine = lines.at(-1) || "";
 
-    // 완료 감지: (1) result 파일 존재, (2) 셸 프롬프트 복귀, (3) "tokens used" 텍스트
     const resultFile = join(RESULT_DIR, `${SESSION}-${paneName}.txt`);
     let resultSize = 0;
-    try { resultSize = statSync(resultFile).size; } catch { /* 파일 미존재 — size 0 유지 */ }
+    try { resultSize = statSync(resultFile).size; } catch { /* missing */ }
 
     const shellReturned = /^(PS\s|>|\$)\s*/.test(lastLine) && lines.length > 2;
-    const tokensLine = lines.find(l => /tokens?\s+used/i.test(l));
-
+    const tokens = extractTokenLabel(snapshot);
     const elapsed = Math.round((Date.now() - startTime) / 1000);
+
     if (resultSize > 10 || shellReturned) {
-      workerState.set(paneName, { paneIdx: pane.index, done: true });
-      const meaningful = lines.filter((l) => !(/^(PS\s|>|\$)/.test(l)) && !(/tokens?\s+used/i.test(l)));
-      const verdict = meaningful.pop() || "completed";
-      tui.updateWorker(paneName, {
-        cli,
-        role: pane.title,
-        status: "completed",
-        handoff: { verdict, confidence: tokensLine ? "high" : "low" },
+      const resultContent = existsSync(resultFile)
+        ? readFileSync(resultFile, "utf8")
+        : 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 handoff = {
+        status: handoffStatus,
+        lead_action: handoffStatus === "failed" ? "retry" : "accept",
+        verdict,
+        confidence: tokens ? "high" : "medium",
+        files_changed: [],
+      };
+
+      ws.done = true;
+      ws.raw_body = resultContent;
+      ws.filtered_body = toFilteredBody(resultContent);
+      ws.verdict = verdict;
+      ws.findings = extractFindings(rLines, verdict);
+      ws.handoff = handoff;
+      ws.progress = 1;
+      ws.activityAt = Date.now();
+
+      pushToTui(paneName, cli, pane.title, {
+        status: handoffStatus === "failed" ? "failed" : "completed",
+        handoff,
+        summary: verdict,
+        detail: ws.filtered_body,
+        findings: ws.findings,
+        tokens,
+        progress: 1,
         elapsed,
       });
-    } else {
-      const meaningful = lines.filter(l => !(/^(PS\s|>|\$)/.test(l)));
-      const snap = meaningful.pop() || lastLine;
-      tui.updateWorker(paneName, { cli, role: pane.title, status: "running", snapshot: snap, elapsed });
+      continue;
     }
-  }
 
-  tui.render();
+    // 진행 중
+    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.verdict = verdict;
+    ws.findings = extractFindings(lines, lastLine);
+    ws.progress = progress;
+    ws.activityAt = Date.now();
+
+    pushToTui(paneName, cli, pane.title, {
+      status: "running",
+      snapshot: lastLine,
+      summary: lastLine,
+      detail: filtered_body,
+      findings: ws.findings,
+      confidence: tokens ? "medium" : "low",
+      tokens,
+      progress,
+      elapsed,
+    });
+  }
 }
 
-// 초기 렌더
-tui.render();
+// ── tui.updateWorker 래퍼 — raw internal data 누출 방지 ──
+function pushToTui(paneName, cli, role, update) {
+  // _leadAction은 tui에 노출하지 않음 (내부용)
+  const { _leadAction: _ignored, ...safeUpdate } = update;
+  tui.updateWorker(paneName, { cli, role, ...safeUpdate });
+}
 
-const timer = setInterval(poll, POLL_MS);
+// ── render 루프 (8-12FPS ≈ 100ms) ──
+let renderTimer = null;
+function startRender() {
+  renderTimer = setInterval(() => { tui.render(); }, 100);
+  if (renderTimer.unref) renderTimer.unref();
+}
 
-// 모든 워커 완료 → 15초 유지 후 종료
+// ── 완료 감지 ──
 const doneCheck = setInterval(() => {
-  if (workerState.size > 0 && [...workerState.values()].every(w => w.done)) {
+  if (workerState.size > 0 && [...workerState.values()].every((w) => w.done)) {
     tui.render();
     clearInterval(doneCheck);
-    setTimeout(() => { tui.close(); clearInterval(timer); process.exit(0); }, 15000);
+    clearInterval(ingestTimer);
+    clearInterval(renderTimer);
+    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); });
+    } else {
+      setTimeout(() => { cleanup(); process.exit(0); }, 30000);
+    }
   }
 }, 2000);
 
-process.on("SIGINT", () => { tui.close(); clearInterval(timer); clearInterval(doneCheck); process.exit(0); });
-setTimeout(() => { tui.close(); clearInterval(timer); clearInterval(doneCheck); process.exit(0); }, 10 * 60 * 1000);
+// ── resize 대응 ──
+process.stdout.on("resize", () => {
+  tui.render();
+});
+
+// ── 정리 ──
+function cleanup() {
+  clearInterval(ingestTimer);
+  clearInterval(renderTimer);
+  clearInterval(doneCheck);
+  tui.close();
+}
+
+// ── 진입점 ──
+tui.render();
+const ingestTimer = setInterval(ingest, 500);   // 2Hz
+startRender();
+
+// 타임아웃 (10분)
+setTimeout(() => { cleanup(); process.exit(0); }, 10 * 60 * 1000);
+
+// Ctrl-C
+process.on("SIGINT", () => { cleanup(); process.exit(0); });