triflux 10.9.19 → 10.9.21

package/hub/team/swarm-hypervisor.mjs

@@ -10,6 +10,7 @@
 //   F4: File lease violation  → revert worker changes, flag shard as failed
 //   F5: Merge conflict        → retry integration with conflict resolution
 
+import { execFile } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -66,6 +67,7 @@ const FAILURE_MODES = Object.freeze({
   F3_STALL: "F3_stall",
   F4_LEASE_VIOLATION: "F4_lease_violation",
   F5_MERGE_CONFLICT: "F5_merge_conflict",
+  F6_NO_COMMIT: "F6_no_commit",
 });
 
 const FALLBACK_AGENTS = Object.freeze({
@@ -249,6 +251,138 @@ export function createSwarmHypervisor(opts) {
     return integrationResult;
   }
 
+  function git(args, cwd = workdir) {
+    return new Promise((resolve, reject) => {
+      execFile(
+        "git",
+        args,
+        { cwd, windowsHide: true, timeout: 30_000 },
+        (err, stdout, stderr) => {
+          if (err) {
+            reject(
+              new Error(
+                `git ${args[0]} failed: ${stderr?.trim() || err.message}`,
+              ),
+            );
+            return;
+          }
+          resolve(stdout.trim());
+        },
+      );
+    });
+  }
+
+  function computeAuthoritativeStatus(shardName, workerEntry, sessions) {
+    const failureInfo = failures.get(shardName) || null;
+    if (failureInfo) {
+      return {
+        status: "failed",
+        reason: failureInfo.mode || failureInfo.reason || "failed",
+      };
+    }
+
+    if (results.has(shardName)) {
+      return { status: "done", reason: "integrated" };
+    }
+
+    if (!sessions.length) {
+      if (completedShards.has(shardName)) {
+        return { status: "done", reason: "awaiting_integration" };
+      }
+      return { status: "running", reason: "no_sessions" };
+    }
+
+    const states = sessions.map((session) => session.state);
+    if (states.every((stateValue) => stateValue === STATES.COMPLETED)) {
+      return { status: "done", reason: "awaiting_integration" };
+    }
+    if (states.some((stateValue) => stateValue === STATES.INPUT_WAIT)) {
+      return { status: "blocked", reason: "user_input" };
+    }
+    if (states.some((stateValue) => stateValue === STATES.STALLED)) {
+      return { status: "stalled", reason: "health_probe_stall" };
+    }
+    if (
+      states.some(
+        (stateValue) =>
+          stateValue === STATES.FAILED || stateValue === STATES.DEAD,
+      )
+    ) {
+      return { status: "failed", reason: "session_terminal" };
+    }
+    if (
+      states.some(
+        (stateValue) =>
+          stateValue === STATES.STARTING ||
+          stateValue === STATES.RESTARTING ||
+          stateValue === STATES.INIT,
+      )
+    ) {
+      return { status: "running", reason: "starting" };
+    }
+
+    return { status: "running", reason: "healthy" };
+  }
+
+  async function collectCommitEvidence(worker, integrationBranch) {
+    const branchName = worker?.branchName || null;
+    const evidence = {
+      branchName,
+      integrationBranch,
+      commitsAhead: 0,
+      dirty: false,
+      dirtyFiles: [],
+      headCommit: null,
+      ok: false,
+      error: null,
+    };
+
+    if (!branchName) {
+      evidence.error = "missing_branch_name";
+      return evidence;
+    }
+
+    try {
+      evidence.commitsAhead =
+        Number.parseInt(
+          await git([
+            "rev-list",
+            "--count",
+            `${integrationBranch}..${branchName}`,
+          ]),
+          10,
+        ) || 0;
+    } catch (err) {
+      evidence.error = err.message;
+      return evidence;
+    }
+
+    try {
+      evidence.headCommit = await git(["rev-parse", branchName]);
+    } catch {
+      /* best-effort */
+    }
+
+    if (worker?.worktreePath && !worker?.shardConfig?.host) {
+      try {
+        const rawStatus = await git(["status", "--short"], worker.worktreePath);
+        evidence.dirtyFiles = rawStatus
+          .split(/\r?\n/)
+          .map((line) => line.trim())
+          .filter(Boolean)
+          .map((line) => line.slice(2).trim())
+          .filter(Boolean);
+        evidence.dirty = evidence.dirtyFiles.length > 0;
+      } catch (err) {
+        evidence.error = evidence.error || err.message;
+        return evidence;
+      }
+    }
+
+    evidence.ok = evidence.commitsAhead > 0 && evidence.dirty === false;
+    return evidence;
+  }
+
   // ── Worker lifecycle ────────────────────────────────────────
 
   function buildSessionConfig(shard) {
@@ -523,6 +657,7 @@ export function createSwarmHypervisor(opts) {
     if (/stall|l1_stall|timeout/u.test(r)) return FAILURE_MODES.F3_STALL;
     if (/lease|violation/u.test(r)) return FAILURE_MODES.F4_LEASE_VIOLATION;
     if (/merge|conflict/u.test(r)) return FAILURE_MODES.F5_MERGE_CONFLICT;
+    if (/no.?commit|dirty_worktree/u.test(r)) return FAILURE_MODES.F6_NO_COMMIT;
     return FAILURE_MODES.F1_CRASH;
   }
 
@@ -603,10 +738,7 @@ export function createSwarmHypervisor(opts) {
         if (shard?.host && shard._remoteEnv) {
           const hostConfig = getHostConfig(shard.host, workdir);
           const sshUser = hostConfig?.ssh_user || shard.host;
-          const remoteRepoPath = resolveRemoteDir(
-            workdir,
-            shard._remoteEnv,
-          );
+          const remoteRepoPath = resolveRemoteDir(workdir, shard._remoteEnv);
           const fetchResult = await fetchRemoteShard({
             host: shard.host,
             sshUser,
@@ -630,6 +762,38 @@ export function createSwarmHypervisor(opts) {
           });
         }
 
+        // Read shard output log for changed files
+        const commitEvidence = await collectCommitEvidence(
+          worker,
+          integrationBranch,
+        );
+        worker.commitEvidence = commitEvidence;
+        eventLog.append("commit_evidence", {
+          shard: shardName,
+          ...commitEvidence,
+        });
+
+        const expectsCommitEvidence =
+          Array.isArray(shard?.files) && shard.files.length > 0;
+        if (expectsCommitEvidence && !commitEvidence.ok) {
+          failures.set(shardName, {
+            mode: FAILURE_MODES.F6_NO_COMMIT,
+            reason: commitEvidence.error
+              ? `no_commit_evidence:${commitEvidence.error}`
+              : commitEvidence.dirty
+                ? "dirty_worktree_without_commit"
+                : "no_commit_evidence",
+            commitEvidence,
+          });
+          eventLog.append("no_commit_guard_failed", {
+            shard: shardName,
+            ...commitEvidence,
+          });
+          await maybeCleanupWorktree(shardName, worker, shard);
+          integrationFailures.push(shardName);
+          continue;
+        }
+
         // Read shard output log for changed files
         const changedFiles = detectChangedFiles(shardName, worker);
 
@@ -856,6 +1020,7 @@ export function createSwarmHypervisor(opts) {
 
     for (const [name, w] of workers) {
       const snap = w.conductor.getSnapshot();
+      const authoritative = computeAuthoritativeStatus(name, w, snap);
       workerStatuses.push({
         shard: name,
         agent: w.shardConfig.agent,
@@ -863,6 +1028,9 @@ export function createSwarmHypervisor(opts) {
         failed: failures.has(name),
         failureInfo: failures.get(name) || null,
         integrated: results.has(name),
+        authoritativeStatus: authoritative.status,
+        authoritativeReason: authoritative.reason,
+        commitEvidence: w.commitEvidence || null,
       });
     }
 
@@ -901,25 +1069,30 @@ export function createSwarmHypervisor(opts) {
   let hubKeepaliveTimer = null;
   function startHubKeepalive() {
     // 5분마다 Hub /status 핑 (idle timeout 기본 10분)
-    hubKeepaliveTimer = setInterval(async () => {
-      try {
-        const resp = await fetch("http://127.0.0.1:27888/status");
-        if (!resp.ok && ensureHubAliveFn) {
-          eventLog.append("hub_keepalive_restart", {});
-          await ensureHubAliveFn();
-        }
-      } catch {
-        // Hub 다운 — 재시작 시도
-        if (ensureHubAliveFn) {
-          eventLog.append("hub_keepalive_restart", { reason: "fetch_failed" });
-          try {
+    hubKeepaliveTimer = setInterval(
+      async () => {
+        try {
+          const resp = await fetch("http://127.0.0.1:27888/status");
+          if (!resp.ok && ensureHubAliveFn) {
+            eventLog.append("hub_keepalive_restart", {});
             await ensureHubAliveFn();
-          } catch {
-            eventLog.append("hub_restart_failed", {});
+          }
+        } catch {
+          // Hub 다운 — 재시작 시도
+          if (ensureHubAliveFn) {
+            eventLog.append("hub_keepalive_restart", {
+              reason: "fetch_failed",
+            });
+            try {
+              await ensureHubAliveFn();
+            } catch {
+              eventLog.append("hub_restart_failed", {});
+            }
           }
         }
-      }
-    }, 5 * 60 * 1000);
+      },
+      5 * 60 * 1000,
+    );
   }
 
   function stopHubKeepalive() {
@@ -939,12 +1112,17 @@ export function createSwarmHypervisor(opts) {
 
     // Hub alive 확인 — 죽어있으면 재시작
     if (ensureHubAliveFn) {
-      ensureHubAliveFn().then((hub) => {
-        eventLog.append("hub_ensured", { port: hub?.port });
-      }).catch((err) => {
-        eventLog.append("hub_ensure_failed", { error: err.message });
-        emitter.emit("warning", { type: "hub_unavailable", error: err.message });
-      });
+      ensureHubAliveFn()
+        .then((hub) => {
+          eventLog.append("hub_ensured", { port: hub?.port });
+        })
+        .catch((err) => {
+          eventLog.append("hub_ensure_failed", { error: err.message });
+          emitter.emit("warning", {
+            type: "hub_unavailable",
+            error: err.message,
+          });
+        });
     }
 
     // Warn about file conflicts but don't block
@@ -1007,7 +1185,7 @@ export function createSwarmHypervisor(opts) {
       `${launched.size} launched, ${pending.size} pending deps`,
     );
 
-    return getStatus();
+    return { ...getStatus(), done: integrationPromise };
   }
 
   /**

package/hub/team/synapse-http.mjs

@@ -1,6 +1,7 @@
 const DEFAULT_SYNAPSE_BASE_URL = "http://127.0.0.1:27888";
 
 function resolveSynapseFetch(fetchImpl) {
+  if (fetchImpl === null) return null;
   if (typeof fetchImpl === "function") return fetchImpl;
   if (typeof globalThis.fetch === "function") {
     return globalThis.fetch.bind(globalThis);

package/hub/team/tui-core.mjs

@@ -0,0 +1,292 @@
+// hub/team/tui-core.mjs — 대시보드 공통 유틸리티 (ISSUE-11)
+// tui.mjs / tui-lite.mjs 간 중복 로직을 단일 모듈로 통합.
+
+import { FG, MOCHA, wcswidth } from "./ansi.mjs";
+
+// ── 상수 ──────────────────────────────────────────────────────────────────
+export const FALLBACK_COLUMNS = 100;
+export const FALLBACK_ROWS = 30;
+export const VALID_TABS = Object.freeze(["log", "detail", "files"]);
+
+// ── 버전 로드 ─────────────────────────────────────────────────────────────
+let _cachedVersion = null;
+export async function loadVersion(fallback = "7.x") {
+  if (_cachedVersion) return _cachedVersion;
+  try {
+    const { createRequire } = await import("node:module");
+    const require = createRequire(import.meta.url);
+    _cachedVersion = require("../../package.json").version;
+  } catch {
+    _cachedVersion = fallback;
+  }
+  return _cachedVersion;
+}
+
+// ── 수학 유틸 ─────────────────────────────────────────────────────────────
+export function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+// ── 텍스트 정규화 ─────────────────────────────────────────────────────────
+export function stripCodeBlocks(text) {
+  return (
+    String(text || "")
+      .replace(/\r/g, "")
+      .replace(/```[\s\S]*?(?:```|$)/g, "\n")
+      .replace(/^\s*```.*$/gm, "")
+      .replace(/^(?: {4}|\t).+$/gm, "")
+      .replace(/^(?:PS\s+\S[^\n]*?>|>\s+|\$\s+)[^\n]*/gm, "")
+      .trim()
+  );
+}
+
+export function sanitizeTextBlock(text, rawMode = false) {
+  const normalized = rawMode
+    ? String(text || "").replace(/\r/g, "")
+    : stripCodeBlocks(text);
+  return normalized
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .filter((line) => line !== "--- HANDOFF ---")
+    .join("\n")
+    .trim();
+}
+
+export function sanitizeOneLine(text, fallback = "") {
+  return sanitizeTextBlock(text).replace(/\s+/g, " ").trim() || fallback;
+}
+
+export function sanitizeFiles(files) {
+  if (!files) return [];
+  const raw = Array.isArray(files) ? files : String(files).split(",");
+  return raw.map((e) => sanitizeOneLine(e)).filter(Boolean);
+}
+
+export function sanitizeFindings(findings) {
+  if (!findings) return [];
+  const raw = Array.isArray(findings)
+    ? findings
+    : sanitizeTextBlock(findings).split("\n");
+  return raw.map((e) => sanitizeOneLine(e)).filter(Boolean);
+}
+
+export function normalizeTokens(tokens) {
+  if (tokens === null || tokens === undefined || tokens === "") return "";
+  if (typeof tokens === "number" && Number.isFinite(tokens)) return tokens;
+  const raw = sanitizeOneLine(tokens);
+  if (!raw) return "";
+  const match = raw.match(/(\d+(?:[.,]\d+)?\s*[kKmM]?)/);
+  return match ? match[1].replace(/\s+/g, "").toLowerCase() : raw;
+}
+
+export function formatTokens(tokens) {
+  if (tokens === null || tokens === undefined || tokens === "") return "n/a";
+  if (typeof tokens === "number" && Number.isFinite(tokens)) {
+    if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}m`;
+    if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}k`;
+    return `${tokens}`;
+  }
+  return String(tokens);
+}
+
+// ── 워커 상태 ─────────────────────────────────────────────────────────────
+export function runtimeStatus(worker) {
+  return worker?.handoff?.status || worker?.status || "pending";
+}
+
+/**
+ * 워커 상태 정규화 (tui.mjs / tui-lite.mjs 공통)
+ * @param {object} existing - 기존 워커 상태
+ * @param {object} state - 새 상태 패치
+ * @param {object} [opts]
+ * @param {boolean} [opts.trackChanges=false] - _prevStatus/_statusChangedAt 추적 (full TUI용)
+ * @param {function} [opts.now=Date.now] - 시간 함수
+ */
+export function normalizeWorkerState(existing = {}, state = {}, opts = {}) {
+  const { trackChanges = false, now = Date.now } = opts;
+
+  const nextHandoff =
+    state.handoff === undefined
+      ? existing.handoff
+      : {
+          ...(existing.handoff || {}),
+          ...(state.handoff || {}),
+          verdict:
+            state.handoff?.verdict !== undefined
+              ? sanitizeOneLine(state.handoff.verdict)
+              : existing.handoff?.verdict,
+          confidence:
+            state.handoff?.confidence !== undefined
+              ? sanitizeOneLine(state.handoff.confidence)
+              : existing.handoff?.confidence,
+          status:
+            state.handoff?.status !== undefined
+              ? sanitizeOneLine(state.handoff.status)
+              : existing.handoff?.status,
+          files_changed:
+            state.handoff?.files_changed !== undefined
+              ? sanitizeFiles(state.handoff.files_changed)
+              : existing.handoff?.files_changed,
+        };
+
+  const merged = {
+    ...existing,
+    ...state,
+    cli:
+      state.cli !== undefined
+        ? sanitizeOneLine(state.cli, existing.cli || "codex")
+        : existing.cli || "codex",
+    role:
+      state.role !== undefined ? sanitizeOneLine(state.role) : existing.role,
+    status:
+      state.status !== undefined
+        ? sanitizeOneLine(state.status, existing.status || "pending")
+        : existing.status || "pending",
+    snapshot:
+      state.snapshot !== undefined
+        ? sanitizeTextBlock(state.snapshot)
+        : existing.snapshot,
+    summary:
+      state.summary !== undefined
+        ? sanitizeTextBlock(state.summary)
+        : existing.summary,
+    detail:
+      state.detail !== undefined
+        ? sanitizeTextBlock(state.detail)
+        : existing.detail,
+    findings:
+      state.findings !== undefined
+        ? sanitizeFindings(state.findings)
+        : existing.findings,
+    files_changed:
+      state.files_changed !== undefined
+        ? sanitizeFiles(state.files_changed)
+        : existing.files_changed,
+    confidence:
+      state.confidence !== undefined
+        ? sanitizeOneLine(state.confidence)
+        : existing.confidence,
+    tokens:
+      state.tokens !== undefined
+        ? normalizeTokens(state.tokens)
+        : existing.tokens,
+    progress:
+      state.progress !== undefined
+        ? clamp(Number(state.progress) || 0, 0, 1)
+        : existing.progress,
+    handoff: nextHandoff,
+  };
+
+  if (trackChanges) {
+    const statusChanged =
+      state.status !== undefined &&
+      sanitizeOneLine(state.status) !== existing.status;
+    merged._prevStatus = statusChanged
+      ? existing.status
+      : existing._prevStatus;
+    merged._statusChangedAt = statusChanged
+      ? now()
+      : existing._statusChangedAt || 0;
+  }
+
+  return merged;
+}
+
+// ── 색상 헬퍼 ─────────────────────────────────────────────────────────────
+export function cliColor(cli) {
+  if (cli === "gemini") return FG.gemini;
+  if (cli === "claude") return FG.claude;
+  if (cli === "codex") return FG.codex;
+  return FG.white;
+}
+
+export function statusColor(status) {
+  if (status === "ok" || status === "completed") return MOCHA.ok;
+  if (status === "partial") return MOCHA.partial;
+  if (status === "failed") return MOCHA.fail;
+  if (status === "running" || status === "in_progress") return MOCHA.executing;
+  return FG.muted;
+}
+
+export function countStatuses(names, workers) {
+  let ok = 0,
+    partial = 0,
+    failed = 0,
+    running = 0;
+  for (const name of names) {
+    const st = workers.get(name);
+    const s = runtimeStatus(st);
+    if (s === "ok" || s === "completed") ok++;
+    else if (s === "partial") partial++;
+    else if (s === "failed") failed++;
+    else if (s === "running" || s === "in_progress") running++;
+  }
+  return { ok, partial, failed, running };
+}
+
+// ── 뷰포트 해상도 ────────────────────────────────────────────────────────
+export function resolveViewportColumns(opts = {}) {
+  const { columns, stream } = opts;
+  const v = Number.isFinite(columns)
+    ? columns
+    : Number.isFinite(stream?.columns)
+      ? stream.columns
+      : Number.isFinite(process.stdout?.columns)
+        ? process.stdout.columns
+        : FALLBACK_COLUMNS;
+  return Math.max(48, v || FALLBACK_COLUMNS);
+}
+
+export function resolveViewportRows(opts = {}) {
+  const { rows, stream } = opts;
+  const v = Number.isFinite(rows)
+    ? rows
+    : Number.isFinite(stream?.rows)
+      ? stream.rows
+      : Number.isFinite(process.stdout?.rows)
+        ? process.stdout.rows
+        : FALLBACK_ROWS;
+  return Math.max(10, v || FALLBACK_ROWS);
+}
+
+// ── 텍스트 래핑 ───────────────────────────────────────────────────────────
+export function wrapLine(text, width) {
+  const limit = Math.max(8, width);
+  const source = String(text || "").trim();
+  if (!source) return [""];
+  const words = source.split(/\s+/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    const candidate = current ? `${current} ${word}` : word;
+    if (wcswidth(candidate) <= limit) {
+      current = candidate;
+      continue;
+    }
+    if (current) {
+      lines.push(current);
+      current = "";
+    }
+    if (wcswidth(word) <= limit) {
+      current = word;
+      continue;
+    }
+    let offset = 0;
+    while (offset < word.length) {
+      lines.push(word.slice(offset, offset + limit));
+      offset += limit;
+    }
+  }
+  if (current) lines.push(current);
+  return lines.length > 0 ? lines : [source.slice(0, limit)];
+}
+
+export function wrapText(text, width, rawMode = false) {
+  const input = sanitizeTextBlock(text, rawMode);
+  if (!input) return [];
+  return input
+    .split("\n")
+    .flatMap((line) => wrapLine(line, width))
+    .filter(Boolean);
+}