triflux 10.0.0 → 10.0.2

package/hub/team/dashboard-layout.mjs

@@ -0,0 +1,33 @@
+const USER_DASHBOARD_LAYOUTS = new Set([
+  "single",
+  "split-2col",
+  "split-3col",
+  "auto",
+  "lite",
+]);
+
+const DASHBOARD_LAYOUTS = new Set([
+  ...USER_DASHBOARD_LAYOUTS,
+  "summary+detail",
+]);
+
+export function normalizeDashboardLayout(value, { allowAuto = true } = {}) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return "single";
+  if (normalized === "auto" && !allowAuto) return "single";
+  return DASHBOARD_LAYOUTS.has(normalized) ? normalized : "single";
+}
+
+export function parseDashboardLayout(value) {
+  return normalizeDashboardLayout(value, { allowAuto: true });
+}
+
+export function resolveDashboardLayout(value, workerCount = 0) {
+  const normalized = normalizeDashboardLayout(value, { allowAuto: true });
+  if (normalized === "lite") return "lite";
+  if (normalized !== "auto") return normalized;
+  if (workerCount >= 4) return "summary+detail";
+  if (workerCount === 3) return "split-3col";
+  if (workerCount === 2) return "split-2col";
+  return "single";
+}

package/hub/team/dashboard-open.mjs

@@ -0,0 +1,153 @@
+import { spawn } from "node:child_process";
+
+import { psmuxExec } from "./psmux.mjs";
+import {
+  detectMultiplexer,
+  focusWtPane,
+  hasWindowsTerminal,
+  resolveAttachCommand,
+  tmuxExec,
+} from "./session.mjs";
+
+function sanitizeWindowTitle(value, fallback = "triflux") {
+  const text = String(value || "").replace(/[\r\n]+/g, " ").trim();
+  return text || fallback;
+}
+
+function sanitizeSessionName(value) {
+  return String(value || "").replace(/[^a-zA-Z0-9_\-]/g, "") || "tfx-session";
+}
+
+function sanitizeWorkingDirectory(value) {
+  const text = String(value || "").replace(/[\r\n\x00-\x1f]/g, "").trim();
+  return text || process.cwd();
+}
+
+export function parseWorkerNumber(value) {
+  const text = String(value || "").trim();
+  const workerMatch = text.match(/^worker-(\d+)$/i);
+  if (workerMatch) return Number.parseInt(workerMatch[1], 10);
+  const paneMatch = text.match(/:(\d+)$/);
+  if (paneMatch) return Number.parseInt(paneMatch[1], 10);
+  return null;
+}
+
+export function decideDashboardOpenMode({ openAll = false, hasWtSession = !!process.env.WT_SESSION } = {}) {
+  if (openAll) return hasWtSession ? "tab" : "window";
+  return hasWtSession ? "split" : "window";
+}
+
+function spawnWindowsTerminal(spec, opts = {}) {
+  if (!hasWindowsTerminal()) return false;
+
+  const {
+    mode = "window",
+    title = "triflux",
+    cwd = process.cwd(),
+    split = { orientation: "H", size: 0.50 },
+  } = opts;
+
+  const safeTitle = sanitizeWindowTitle(title);
+  const safeCwd = sanitizeWorkingDirectory(cwd);
+  const orientation = split?.orientation === "V" ? "V" : "H";
+  const size = Number.isFinite(split?.size) ? Math.min(0.8, Math.max(0.2, split.size)) : 0.50;
+  const baseArgs = ["--profile", "triflux", "--title", safeTitle, "-d", safeCwd, "--", spec.command, ...spec.args];
+  const args = mode === "split"
+    ? ["-w", "0", "sp", `-${orientation}`, "-s", String(size), ...baseArgs]
+    : mode === "tab"
+      ? ["-w", "0", "nt", ...baseArgs]
+      : ["-w", "new", ...baseArgs];
+
+  const child = spawn("wt.exe", args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: false,
+  });
+  child.unref();
+  return true;
+}
+
+export function focusManagedPane(target, opts = {}) {
+  const { teammateMode = "", layout = "1xN" } = opts;
+  const paneRef = String(target || "");
+
+  if (teammateMode === "wt" || paneRef.startsWith("wt:")) {
+    const paneIndex = parseWorkerNumber(paneRef);
+    return paneIndex != null && focusWtPane(paneIndex, { layout });
+  }
+
+  if (!paneRef) return false;
+  try {
+    if (detectMultiplexer() === "psmux") psmuxExec(["select-pane", "-t", paneRef]);
+    else tmuxExec(`select-pane -t ${paneRef}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function openHeadlessDashboardTarget(sessionName, opts = {}) {
+  const {
+    worker = null,
+    openAll = false,
+    cwd = process.cwd(),
+    title,
+  } = opts;
+
+  const safeSession = sanitizeSessionName(sessionName);
+  const workerNumber = worker == null ? null : parseWorkerNumber(worker);
+
+  // 선택 워커 → pane focus만 (새 창 열지 않음)
+  if (!openAll && workerNumber != null) {
+    try {
+      psmuxExec(["select-pane", "-t", `${safeSession}:0.${workerNumber}`]);
+    } catch {}
+    return true;
+  }
+
+  // 전체 열기 (Shift+Enter) → 새 WT 창으로 세션 attach
+  return spawnWindowsTerminal(
+    { command: "psmux", args: ["attach-session", "-t", safeSession] },
+    {
+      mode: decideDashboardOpenMode({ openAll }),
+      title: title || `▲ ${safeSession}`,
+      cwd,
+    },
+  );
+}
+
+export function openDashboardRuntimeTarget(runtime, opts = {}) {
+  const {
+    teammateMode = "",
+    sessionName = "",
+    targetPane = "",
+    layout = "1xN",
+    openAll = false,
+    cwd = process.cwd(),
+    title = "",
+  } = { ...runtime, ...opts };
+
+  if (teammateMode === "headless") {
+    return openHeadlessDashboardTarget(sessionName, {
+      worker: openAll ? null : targetPane,
+      openAll,
+      cwd,
+      title,
+    });
+  }
+
+  if ((teammateMode === "wt" || String(targetPane).startsWith("wt:")) && !openAll) {
+    return focusManagedPane(targetPane, { teammateMode: "wt", layout });
+  }
+
+  try {
+    if (!openAll && targetPane) focusManagedPane(targetPane, { teammateMode, layout });
+    return spawnWindowsTerminal(resolveAttachCommand(sessionName), {
+      mode: decideDashboardOpenMode({ openAll }),
+      title: title || `▲ ${sanitizeSessionName(sessionName)}`,
+      cwd,
+    });
+  } catch {
+    return false;
+  }
+}

package/hub/team/dashboard.mjs

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+// hub/team/dashboard.mjs — 실시간 팀 상태 표시 (v2.2)
+// tmux 의존 제거 — Hub task-list + native-supervisor 기반
+//
+// 실행:
+//   node hub/team/dashboard.mjs --session <세션이름> [--interval 2]
+//   node hub/team/dashboard.mjs --team <팀이름> [--interval 2]
+import { get } from "node:http";
+import { AMBER, GREEN, RED, GRAY, DIM, BOLD, RESET } from "./shared.mjs";
+
+/**
+ * HTTP GET JSON
+ * @param {string} url
+ * @returns {Promise<object|null>}
+ */
+function fetchJson(url) {
+  return new Promise((resolve) => {
+    const req = get(url, { timeout: 2000 }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try { resolve(JSON.parse(data)); } catch { resolve(null); }
+      });
+    });
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => { req.destroy(); resolve(null); });
+  });
+}
+
+/**
+ * HTTP POST JSON (Hub bridge 용)
+ * @param {string} url
+ * @param {object} body
+ * @returns {Promise<object|null>}
+ */
+async function fetchPost(url, body = {}) {
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(2000),
+    });
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 진행률 바 생성
+ * @param {number} pct — 0~100
+ * @param {number} width — 바 너비 (기본 8)
+ * @returns {string}
+ */
+function progressBar(pct, width = 8) {
+  const filled = Math.round((pct / 100) * width);
+  const empty = width - filled;
+  return `${GREEN}${"█".repeat(filled)}${GRAY}${"░".repeat(empty)}${RESET}`;
+}
+
+/**
+ * 업타임 포맷
+ * @param {number} ms
+ * @returns {string}
+ */
+function formatUptime(ms) {
+  if (ms < 60000) return `${Math.round(ms / 1000)}초`;
+  if (ms < 3600000) return `${Math.round(ms / 60000)}분`;
+  return `${Math.round(ms / 3600000)}시간`;
+}
+
+/**
+ * task 상태 아이콘
+ * @param {string} status
+ * @returns {string}
+ */
+function statusIcon(status) {
+  switch (status) {
+    case "completed": return `${GREEN}✓${RESET}`;
+    case "in_progress": return `${AMBER}●${RESET}`;
+    case "failed": return `${RED}✗${RESET}`;
+    default: return `${GRAY}○${RESET}`;
+  }
+}
+
+/**
+ * 멤버 목록 구성: Hub tasks + supervisor + teamState 통합
+ * @param {Array} hubTasks — Hub bridge task-list 결과
+ * @param {Array} supervisorMembers — native-supervisor 멤버 상태
+ * @param {object} teamState — team-state.json 내용
+ * @returns {Array<{name: string, cli: string, status: string, subject: string, preview: string}>}
+ */
+function buildMemberList(hubTasks, supervisorMembers, teamState) {
+  const members = [];
+  const supervisorByName = new Map(supervisorMembers.map((m) => [m.name, m]));
+
+  // Hub tasks가 있으면 주 데이터 소스
+  if (hubTasks.length > 0) {
+    for (const task of hubTasks) {
+      const owner = task.owner || task.subject || "";
+      const sup = supervisorByName.get(owner);
+      members.push({
+        name: owner,
+        cli: task.metadata?.cli || sup?.cli || "",
+        status: task.status || "pending",
+        subject: task.subject || "",
+        preview: sup?.lastPreview || task.description?.slice(0, 80) || "",
+      });
+    }
+    return members;
+  }
+
+  // Supervisor 데이터 폴백
+  if (supervisorMembers.length > 0) {
+    for (const m of supervisorMembers) {
+      if (m.role === "lead") continue;
+      members.push({
+        name: m.name,
+        cli: m.cli || "",
+        status: m.status === "running" ? "in_progress" : m.status === "exited" ? "completed" : m.status,
+        subject: "",
+        preview: m.lastPreview || "",
+      });
+    }
+    return members;
+  }
+
+  // teamState 폴백 (하위 호환)
+  const panes = teamState?.panes || {};
+  for (const [, paneInfo] of Object.entries(panes).filter(([, v]) => v.role !== "dashboard" && v.role !== "lead")) {
+    members.push({
+      name: paneInfo.agentId || paneInfo.name || "?",
+      cli: paneInfo.cli || "",
+      status: "unknown",
+      subject: paneInfo.subtask || "",
+      preview: "",
+    });
+  }
+  return members;
+}
+
+/**
+ * 대시보드 렌더링 (v2.2: Hub/supervisor 기반)
+ * @param {string} sessionName — 세션 또는 팀 이름
+ * @param {object} opts
+ * @param {string} opts.hubUrl — Hub URL (기본 http://127.0.0.1:27888)
+ * @param {string} [opts.teamName] — Hub task-list 조회용 팀 이름
+ * @param {string} [opts.supervisorUrl] — native-supervisor 제어 URL
+ * @param {object} [opts.teamState] — team-state.json 내용 (하위 호환)
+ */
+export async function renderDashboard(sessionName, opts = {}) {
+  const {
+    hubUrl = "http://127.0.0.1:27888",
+    teamName,
+    supervisorUrl,
+    teamState = {},
+  } = opts;
+  const W = 50;
+  const border = "─".repeat(W);
+
+  // 데이터 수집 (병렬)
+  const [hubStatus, taskListRes, supervisorRes] = await Promise.all([
+    fetchJson(`${hubUrl}/status`),
+    teamName ? fetchPost(`${hubUrl}/bridge/team/task-list`, { team_name: teamName }) : null,
+    supervisorUrl ? fetchJson(`${supervisorUrl}/status`) : null,
+  ]);
+
+  const hubOnline = !!hubStatus;
+  const hubState = hubOnline ? `${GREEN}● online${RESET}` : `${RED}● offline${RESET}`;
+  const uptime = hubStatus?.hub?.uptime ? formatUptime(hubStatus.hub.uptime) : "-";
+  const queueSize = hubStatus?.hub?.queue_depth ?? 0;
+
+  // Hub task 데이터
+  const hubTasks = taskListRes?.ok ? (taskListRes.data?.tasks || []) : [];
+  const completedCount = hubTasks.filter((t) => t.status === "completed").length;
+  const totalCount = hubTasks.length;
+
+  // Supervisor 멤버 데이터
+  const supervisorMembers = supervisorRes?.ok ? (supervisorRes.data?.members || []) : [];
+
+  // 헤더
+  const progress = totalCount > 0 ? ` ${completedCount}/${totalCount}` : "";
+  console.log(`${AMBER}┌─ ${sessionName}${progress} ${GRAY}${"─".repeat(Math.max(0, W - sessionName.length - progress.length - 3))}${AMBER}┐${RESET}`);
+  console.log(`${AMBER}│${RESET} Hub: ${hubState}  Uptime: ${DIM}${uptime}${RESET}  Queue: ${DIM}${queueSize}${RESET}`);
+  console.log(`${AMBER}│${RESET}`);
+
+  // 멤버/워커 렌더링
+  const members = buildMemberList(hubTasks, supervisorMembers, teamState);
+
+  if (members.length === 0) {
+    console.log(`${AMBER}│${RESET}  ${DIM}에이전트 정보 없음${RESET}`);
+  } else {
+    for (const m of members) {
+      const icon = statusIcon(m.status);
+      const label = `[${m.name}]`;
+      const cliTag = m.cli ? m.cli.charAt(0).toUpperCase() + m.cli.slice(1) : "";
+
+      // 진행률 추정
+      const pct = m.status === "completed" ? 100
+        : m.status === "in_progress" ? 50
+        : m.status === "failed" ? 100
+        : 0;
+
+      console.log(`${AMBER}│${RESET}  ${BOLD}${label}${RESET} ${cliTag}  ${icon} ${m.status || "pending"}  ${progressBar(pct)}`);
+
+      // 미리보기: supervisor lastPreview > task subject
+      const preview = m.preview || m.subject || "";
+      if (preview) {
+        const truncated = preview.length > W - 8 ? preview.slice(0, W - 11) + "..." : preview;
+        console.log(`${AMBER}│${RESET}    ${DIM}> ${truncated}${RESET}`);
+      }
+      console.log(`${AMBER}│${RESET}`);
+    }
+  }
+
+  // 푸터
+  console.log(`${AMBER}└${GRAY}${border}${AMBER}┘${RESET}`);
+}
+
+/** team-state.json 로드 (세션별 파일 우선, fallback: team-state.json) */
+async function loadTeamState() {
+  try {
+    const { existsSync, readFileSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const { homedir } = await import("node:os");
+    const hubDir = join(homedir(), ".claude", "cache", "tfx-hub");
+    const sessionId = process.env.CLAUDE_SESSION_ID;
+    if (sessionId) {
+      const sessionPath = join(hubDir, `team-state-${sessionId}.json`);
+      if (existsSync(sessionPath)) return JSON.parse(readFileSync(sessionPath, "utf8"));
+    }
+    const legacyPath = join(hubDir, "team-state.json");
+    if (existsSync(legacyPath)) return JSON.parse(readFileSync(legacyPath, "utf8"));
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+// ── CLI 실행 ──
+if (process.argv[1]?.includes("dashboard.mjs")) {
+  const sessionIdx = process.argv.indexOf("--session");
+  const teamIdx = process.argv.indexOf("--team");
+  const sessionName = sessionIdx !== -1 ? process.argv[sessionIdx + 1] : null;
+  const teamName = teamIdx !== -1 ? process.argv[teamIdx + 1] : null;
+  const intervalSec = parseInt(process.argv[process.argv.indexOf("--interval") + 1] || "2", 10);
+
+  const displayName = sessionName || teamName;
+  if (!displayName) {
+    console.error("사용법: node dashboard.mjs --session <세션이름> [--team <팀이름>] [--interval 2]");
+    process.exit(1);
+  }
+
+  // Ctrl+C로 종료
+  process.on("SIGINT", () => process.exit(0));
+
+  // 갱신 루프
+  while (true) {
+    const teamState = await loadTeamState();
+    const effectiveTeamName = teamName || null;
+    const supervisorUrl = teamState?.native?.controlUrl || null;
+
+    // 화면 클리어 (ANSI)
+    process.stdout.write("\x1b[2J\x1b[H");
+    await renderDashboard(displayName, {
+      teamName: effectiveTeamName,
+      supervisorUrl,
+      teamState,
+    });
+    console.log(`${DIM}  ${intervalSec}초 간격 갱신 | Ctrl+C로 종료${RESET}`);
+    await new Promise((r) => setTimeout(r, intervalSec * 1000));
+  }
+}

package/hub/team/event-log.mjs

@@ -0,0 +1,76 @@
+// hub/team/event-log.mjs — JSONL 블랙박스 리코더
+// Conductor 세션 lifecycle 이벤트를 JSONL 파일에 기록한다.
+// 기존 hub/server.mjs의 batch-events.jsonl(MCP 이벤트)과 독립. 공존.
+
+import { createWriteStream, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+/**
+ * JSONL event log 팩토리.
+ * @param {string} filePath — 로그 파일 경로 (.jsonl)
+ * @param {object} [opts]
+ * @param {string} [opts.sessionId] — 모든 이벤트에 자동 삽입할 세션 ID
+ * @returns {{ append, flush, close, filePath }}
+ */
+export function createEventLog(filePath, opts = {}) {
+  const { sessionId } = opts;
+
+  mkdirSync(dirname(filePath), { recursive: true });
+  const stream = createWriteStream(filePath, { flags: 'a' });
+
+  let closed = false;
+  let pending = 0;
+
+  /**
+   * 이벤트를 JSONL 한 줄로 기록.
+   * @param {string} event — 이벤트 타입 (spawn, health, kill, stateChange, ...)
+   * @param {object} [data] — 이벤트 페이로드
+   */
+  function append(event, data = {}) {
+    if (closed) return;
+    const entry = {
+      ts: new Date().toISOString(),
+      ...(sessionId ? { session: sessionId } : {}),
+      event,
+      ...data,
+    };
+    pending += 1;
+    stream.write(JSON.stringify(entry) + '\n', () => { pending -= 1; });
+  }
+
+  /**
+   * 버퍼된 이벤트를 디스크에 flush.
+   * @returns {Promise<void>}
+   */
+  function flush() {
+    if (closed) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      stream.once('error', reject);
+      stream.write('', () => {
+        stream.removeListener('error', reject);
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * 스트림 종료. flush 후 close.
+   * @returns {Promise<void>}
+   */
+  function close() {
+    if (closed) return Promise.resolve();
+    closed = true;
+    return new Promise((resolve) => {
+      stream.end(() => resolve());
+    });
+  }
+
+  return Object.freeze({
+    append,
+    flush,
+    close,
+    get filePath() { return filePath; },
+    get pending() { return pending; },
+    get closed() { return closed; },
+  });
+}