triflux 10.3.4 → 10.7.0

package/hub/team/remote-watcher.mjs

@@ -9,9 +9,8 @@
 
 import { execFileSync } from "node:child_process";
 import { EventEmitter } from "node:events";
-
+import { detectHostOs, shellQuoteForHost } from "../lib/ssh-command.mjs";
 import { detectInputWait, PROBE_LEVELS } from "./health-probe.mjs";
-import { shellQuoteForHost, detectHostOs } from "../lib/ssh-command.mjs";
 
 export const REMOTE_WATCHER_STATES = Object.freeze({
   WATCHING: "watching",
@@ -62,7 +61,10 @@ function freezeStatus(status) {
     Object.fromEntries(
       Object.entries(status.sessions || {})
         .sort(([left], [right]) => left.localeCompare(right))
-        .map(([sessionName, record]) => [sessionName, freezeSessionRecord(record)]),
+        .map(([sessionName, record]) => [
+          sessionName,
+          freezeSessionRecord(record),
+        ]),
     ),
   );
 
@@ -117,7 +119,9 @@ function hasMeaningfulActivity(captured) {
 }
 
 function detectCompletion(captured) {
-  const matches = Array.from(String(captured || "").matchAll(COMPLETION_TOKEN_RE));
+  const matches = Array.from(
+    String(captured || "").matchAll(COMPLETION_TOKEN_RE),
+  );
   const match = matches.at(-1);
   if (!match) {
     return {
@@ -128,7 +132,8 @@ function detectCompletion(captured) {
     };
   }
 
-  const parsedExitCode = match[2] == null ? null : Number.parseInt(match[2], 10);
+  const parsedExitCode =
+    match[2] == null ? null : Number.parseInt(match[2], 10);
   return {
     detected: true,
     exitCode: Number.isFinite(parsedExitCode) ? parsedExitCode : null,
@@ -143,7 +148,10 @@ function parseSessionNames(rawOutput, sessionPrefix) {
     .map((line) => line.trim())
     .filter(Boolean)
     .map((line) => line.split(":")[0]?.trim())
-    .filter((sessionName) => Boolean(sessionName) && sessionName.startsWith(sessionPrefix));
+    .filter(
+      (sessionName) =>
+        Boolean(sessionName) && sessionName.startsWith(sessionPrefix),
+    );
 }
 
 function buildExecOptions(config) {
@@ -187,7 +195,9 @@ function captureSpawnSession(sessionName, config) {
   );
   return {
     paneTarget,
-    captured: String(output || "").replace(/\r/g, "").trimEnd(),
+    captured: String(output || "")
+      .replace(/\r/g, "")
+      .trimEnd(),
   };
 }
 
@@ -221,7 +231,10 @@ function createSessionRecord(sessionName, config, now) {
 }
 
 function isTerminalState(state) {
-  return state === REMOTE_WATCHER_STATES.COMPLETED || state === REMOTE_WATCHER_STATES.FAILED;
+  return (
+    state === REMOTE_WATCHER_STATES.COMPLETED ||
+    state === REMOTE_WATCHER_STATES.FAILED
+  );
 }
 
 export function createRemoteWatcher(opts = {}) {
@@ -252,26 +265,30 @@ export function createRemoteWatcher(opts = {}) {
   }
 
   function emitSessionEvent(eventName, nextRecord, now) {
-    emitter.emit(eventName, Object.freeze({
-      exitCode: nextRecord.exitCode,
-      host: nextRecord.host,
-      inputWaitPattern: nextRecord.inputWaitPattern,
-      output: nextRecord.lastOutput,
-      paneTarget: nextRecord.paneTarget,
-      probeLevel: nextRecord.lastProbeLevel,
-      promptIdlePattern: nextRecord.promptIdlePattern,
-      reason: nextRecord.reason,
-      sessionName: nextRecord.sessionName,
-      state: nextRecord.state,
-      ts: now,
-    }));
+    emitter.emit(
+      eventName,
+      Object.freeze({
+        exitCode: nextRecord.exitCode,
+        host: nextRecord.host,
+        inputWaitPattern: nextRecord.inputWaitPattern,
+        output: nextRecord.lastOutput,
+        paneTarget: nextRecord.paneTarget,
+        probeLevel: nextRecord.lastProbeLevel,
+        promptIdlePattern: nextRecord.promptIdlePattern,
+        reason: nextRecord.reason,
+        sessionName: nextRecord.sessionName,
+        state: nextRecord.state,
+        ts: now,
+      }),
+    );
   }
 
   function classifySession(previousRecord, captured, now) {
     const completion = detectCompletion(captured);
     const inputWait = detectInputWait(captured);
     const promptIdle = detectPromptIdle(captured);
-    const hasActivity = previousRecord.hasActivity || hasMeaningfulActivity(captured);
+    const hasActivity =
+      previousRecord.hasActivity || hasMeaningfulActivity(captured);
 
     let nextState = REMOTE_WATCHER_STATES.WATCHING;
     let reason = "watching";
@@ -292,9 +309,9 @@ export function createRemoteWatcher(opts = {}) {
         eventName = "sessionCompleted";
       }
     } else if (
-      promptIdle.detected
-      && hasActivity
-      && (!inputWait.detected || inputWait.pattern === BARE_INPUT_WAIT_PATTERN)
+      promptIdle.detected &&
+      hasActivity &&
+      (!inputWait.detected || inputWait.pattern === BARE_INPUT_WAIT_PATTERN)
     ) {
       nextState = REMOTE_WATCHER_STATES.COMPLETED;
       reason = "prompt_idle";
@@ -325,10 +342,10 @@ export function createRemoteWatcher(opts = {}) {
     };
 
     if (
-      eventName
-      && previousRecord.state === nextRecord.state
-      && previousRecord.reason === nextRecord.reason
-      && previousRecord.exitCode === nextRecord.exitCode
+      eventName &&
+      previousRecord.state === nextRecord.state &&
+      previousRecord.reason === nextRecord.reason &&
+      previousRecord.exitCode === nextRecord.exitCode
     ) {
       return { eventName: null, nextRecord };
     }
@@ -375,7 +392,10 @@ export function createRemoteWatcher(opts = {}) {
           : createSessionRecord(sessionName, config, now);
 
         try {
-          const { paneTarget, captured } = captureSpawnSession(sessionName, config);
+          const { paneTarget, captured } = captureSpawnSession(
+            sessionName,
+            config,
+          );
           const { eventName, nextRecord } = classifySession(
             { ...previousRecord, paneTarget },
             captured,
@@ -396,7 +416,10 @@ export function createRemoteWatcher(opts = {}) {
             state: REMOTE_WATCHER_STATES.FAILED,
           };
           nextSessions[sessionName] = failedRecord;
-          queuedEvents.push({ eventName: "sessionFailed", record: failedRecord });
+          queuedEvents.push({
+            eventName: "sessionFailed",
+            record: failedRecord,
+          });
           setStatus({
             ...status,
             lastError: toErrorRecord(error),
@@ -407,9 +430,14 @@ export function createRemoteWatcher(opts = {}) {
         }
       }
 
-      for (const [sessionName, previousRecord] of Object.entries(status.sessions)) {
+      for (const [sessionName, previousRecord] of Object.entries(
+        status.sessions,
+      )) {
         if (activeSet.has(sessionName)) continue;
-        const { eventName, nextRecord } = markMissingSession(previousRecord, now);
+        const { eventName, nextRecord } = markMissingSession(
+          previousRecord,
+          now,
+        );
         nextSessions[sessionName] = nextRecord;
         if (eventName) {
           queuedEvents.push({ eventName, record: nextRecord });

package/hub/team/routing.mjs

@@ -15,31 +15,55 @@
 export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
   const N = subtasks.length;
   if (N === 0) {
-    const dagContext = { dag_width: 0, levels: {}, edges: [], max_complexity: 'S', taskResults: {} };
-    return { strategy: 'quick_single', reason: 'empty_subtasks', dag_width: 0, max_complexity: 'S', dagContext };
+    const dagContext = {
+      dag_width: 0,
+      levels: {},
+      edges: [],
+      max_complexity: "S",
+      taskResults: {},
+    };
+    return {
+      strategy: "quick_single",
+      reason: "empty_subtasks",
+      dag_width: 0,
+      max_complexity: "S",
+      dagContext,
+    };
   }
 
-  const { width: dag_width, levels, edges } = computeDagInfo(subtasks, graph_type);
+  const {
+    width: dag_width,
+    levels,
+    edges,
+  } = computeDagInfo(subtasks, graph_type);
   const max_complexity = getMaxComplexity(subtasks);
-  const dagContext = { dag_width, levels, edges, max_complexity, taskResults: {} };
-  const isHighComplexity = ['L', 'XL'].includes(max_complexity);
+  const dagContext = {
+    dag_width,
+    levels,
+    edges,
+    max_complexity,
+    taskResults: {},
+  };
+  const isHighComplexity = ["L", "XL"].includes(max_complexity);
   const allSameAgent = new Set(subtasks.map((s) => s.agent)).size === 1;
-  const allSmall = subtasks.every((s) => normalizeComplexity(s.complexity) === 'S');
+  const allSmall = subtasks.every(
+    (s) => normalizeComplexity(s.complexity) === "S",
+  );
 
   // N==1: 단일 태스크
   if (N === 1) {
     if (thorough || isHighComplexity) {
       return {
-        strategy: 'thorough_single',
-        reason: 'single_high_complexity',
+        strategy: "thorough_single",
+        reason: "single_high_complexity",
         dag_width,
         max_complexity,
         dagContext,
       };
     }
     return {
-      strategy: 'quick_single',
-      reason: 'single_low_complexity',
+      strategy: "quick_single",
+      reason: "single_low_complexity",
       dag_width,
       max_complexity,
       dagContext,
@@ -50,16 +74,16 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
   if (dag_width === 1) {
     if (thorough || isHighComplexity) {
       return {
-        strategy: 'thorough_single',
-        reason: 'sequential_chain',
+        strategy: "thorough_single",
+        reason: "sequential_chain",
         dag_width,
         max_complexity,
         dagContext,
       };
     }
     return {
-      strategy: 'quick_single',
-      reason: 'sequential_chain',
+      strategy: "quick_single",
+      reason: "sequential_chain",
       dag_width,
       max_complexity,
       dagContext,
@@ -69,8 +93,8 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
   // 동일 에이전트 + 모두 S: 프롬프트 병합 -> batch single
   if (allSameAgent && allSmall) {
     return {
-      strategy: 'batch_single',
-      reason: 'same_agent_small_batch',
+      strategy: "batch_single",
+      reason: "same_agent_small_batch",
       dag_width,
       max_complexity,
       dagContext,
@@ -80,16 +104,16 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
   // dag_width >= 2: 팀
   if (thorough || isHighComplexity) {
     return {
-      strategy: 'thorough_team',
-      reason: 'parallel_high_complexity',
+      strategy: "thorough_team",
+      reason: "parallel_high_complexity",
       dag_width,
       max_complexity,
       dagContext,
     };
   }
   return {
-    strategy: 'quick_team',
-    reason: 'parallel_low_complexity',
+    strategy: "quick_team",
+    reason: "parallel_low_complexity",
     dag_width,
     max_complexity,
     dagContext,
@@ -103,7 +127,7 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
  * @returns {{ width: number, levels: Record<number, string[]>, edges: Array<{from:string, to:string}> }}
  */
 function computeDagInfo(subtasks, graph_type) {
-  if (graph_type === 'SEQUENTIAL') {
+  if (graph_type === "SEQUENTIAL") {
     const levels = {};
     const edges = [];
     subtasks.forEach((t, i) => {
@@ -112,7 +136,7 @@ function computeDagInfo(subtasks, graph_type) {
     });
     return { width: 1, levels, edges };
   }
-  if (graph_type === 'INDEPENDENT') {
+  if (graph_type === "INDEPENDENT") {
     const levels = { 0: subtasks.map((t) => t.id) };
     return { width: subtasks.length, levels, edges: [] };
   }
@@ -173,7 +197,9 @@ function computeDagInfo(subtasks, graph_type) {
 export function getUpstreamResults(taskId, pipelineState) {
   const ctx = pipelineState?.dagContext;
   if (!ctx) return {};
-  const upstreamIds = ctx.edges.filter((e) => e.to === taskId).map((e) => e.from);
+  const upstreamIds = ctx.edges
+    .filter((e) => e.to === taskId)
+    .map((e) => e.from);
   const results = {};
   for (const id of upstreamIds) {
     if (id in (ctx.taskResults || {})) {
@@ -205,7 +231,7 @@ export function updateTaskResult(taskId, result, pipelineState) {
  */
 function getMaxComplexity(subtasks) {
   const order = { S: 0, M: 1, L: 2, XL: 3 };
-  let max = 'S';
+  let max = "S";
   for (const s of subtasks) {
     const complexity = normalizeComplexity(s.complexity);
     if (order[complexity] > order[max]) max = complexity;
@@ -219,5 +245,5 @@ function getMaxComplexity(subtasks) {
  * @returns {"S" | "M" | "L" | "XL"}
  */
 function normalizeComplexity(complexity) {
-  return ['S', 'M', 'L', 'XL'].includes(complexity) ? complexity : 'M';
+  return ["S", "M", "L", "XL"].includes(complexity) ? complexity : "M";
 }

package/hub/team/runtime-strategy.mjs

@@ -60,7 +60,9 @@ export function createPsmuxRuntime(adapter = defaultPsmuxAdapter) {
  * @returns {TeamRuntime & { name: string }}
  */
 export function createRuntime(mode) {
-  const normalizedMode = String(mode || "").trim().toLowerCase();
+  const normalizedMode = String(mode || "")
+    .trim()
+    .toLowerCase();
 
   if (normalizedMode === "psmux") {
     return createPsmuxRuntime();

package/hub/team/session.mjs

@@ -22,7 +22,11 @@ const GIT_BASH_CANDIDATES = [
 function findGitBashExe() {
   for (const p of GIT_BASH_CANDIDATES) {
     try {
-      execSync(`"${p}" --version`, { stdio: "ignore", timeout: 3000, windowsHide: true });
+      execSync(`"${p}" --version`, {
+        stdio: "ignore",
+        timeout: 3000,
+        windowsHide: true,
+      });
       return p;
     } catch {
       // 다음 후보
@@ -35,7 +39,11 @@ function findGitBashExe() {
 export function hasWindowsTerminal() {
   if (process.platform !== "win32") return false;
   try {
-    execSync("where wt.exe", { stdio: "ignore", timeout: 3000, windowsHide: true });
+    execSync("where wt.exe", {
+      stdio: "ignore",
+      timeout: 3000,
+      windowsHide: true,
+    });
     return true;
   } catch {
     return false;
@@ -60,7 +68,11 @@ function hasTmux() {
 /** WSL2 내 tmux 사용 가능 여부 (Windows 전용) */
 function hasWslTmux() {
   try {
-    execSync("wsl tmux -V", { stdio: "ignore", timeout: 5000, windowsHide: true });
+    execSync("wsl tmux -V", {
+      stdio: "ignore",
+      timeout: 5000,
+      windowsHide: true,
+    });
     return true;
   } catch {
     return false;
@@ -91,10 +103,22 @@ function hasGitBashTmux() {
 let _cachedMux;
 export function detectMultiplexer() {
   if (_cachedMux !== undefined) return _cachedMux;
-  if (hasPsmux()) { _cachedMux = "psmux"; return _cachedMux; }
-  if (hasTmux()) { _cachedMux = "tmux"; return _cachedMux; }
-  if (process.platform === "win32" && hasGitBashTmux()) { _cachedMux = "git-bash-tmux"; return _cachedMux; }
-  if (process.platform === "win32" && hasWslTmux()) { _cachedMux = "wsl-tmux"; return _cachedMux; }
+  if (hasPsmux()) {
+    _cachedMux = "psmux";
+    return _cachedMux;
+  }
+  if (hasTmux()) {
+    _cachedMux = "tmux";
+    return _cachedMux;
+  }
+  if (process.platform === "win32" && hasGitBashTmux()) {
+    _cachedMux = "git-bash-tmux";
+    return _cachedMux;
+  }
+  if (process.platform === "win32" && hasWslTmux()) {
+    _cachedMux = "wsl-tmux";
+    return _cachedMux;
+  }
   _cachedMux = null;
   return _cachedMux;
 }
@@ -110,15 +134,15 @@ function tmux(args, opts = {}) {
   if (!mux) {
     throw new Error(
       "tmux/psmux 미발견.\n\n" +
-      "tfx multi은 tmux 계열 멀티플렉서가 필요합니다:\n" +
-      "  Windows: psmux 설치 또는 WSL2 tmux 사용\n" +
-      "  WSL2:   wsl sudo apt install tmux\n" +
-      "  macOS:  brew install tmux\n" +
-      "  Linux:  apt install tmux\n\n" +
-      "Windows에서는 WSL2를 권장합니다:\n" +
-      "  1. wsl --install\n" +
-      "  2. wsl sudo apt install tmux\n" +
-      "  3. tfx multi \"작업\"  (자동으로 WSL tmux 사용)"
+        "tfx multi은 tmux 계열 멀티플렉서가 필요합니다:\n" +
+        "  Windows: psmux 설치 또는 WSL2 tmux 사용\n" +
+        "  WSL2:   wsl sudo apt install tmux\n" +
+        "  macOS:  brew install tmux\n" +
+        "  Linux:  apt install tmux\n\n" +
+        "Windows에서는 WSL2를 권장합니다:\n" +
+        "  1. wsl --install\n" +
+        "  2. wsl sudo apt install tmux\n" +
+        '  3. tfx multi "작업"  (자동으로 WSL tmux 사용)',
     );
   }
   if (mux === "psmux") {
@@ -272,7 +296,17 @@ export function createWtSession(sessionName, opts = {}) {
     const cwd = pane.cwd || process.cwd();
     if (!command) continue;
 
-    wt(["-w", "0", "sp", splitFlag, "--title", title, "-d", cwd, ...buildWtCmdArgs(command)]);
+    wt([
+      "-w",
+      "0",
+      "sp",
+      splitFlag,
+      "--title",
+      title,
+      "-d",
+      cwd,
+      ...buildWtCmdArgs(command),
+    ]);
     panes.push(`wt:${i}`);
     titles.push(title);
   }
@@ -305,7 +339,11 @@ export function focusWtPane(paneIndex, opts = {}) {
 
   // 앵커로 최대한 복귀
   for (let i = 0; i < 10; i++) {
-    try { wt(["-w", "0", "move-focus", backDir]); } catch { break; }
+    try {
+      wt(["-w", "0", "move-focus", backDir]);
+    } catch {
+      break;
+    }
   }
 
   for (let i = 0; i <= idx; i++) {
@@ -334,7 +372,11 @@ export function closeWtSession(opts = {}) {
 
   // 앵커(원래 tfx 실행 pane)로 최대한 복귀
   for (let i = 0; i < 10; i++) {
-    try { wt(["-w", "0", "move-focus", backDir]); } catch { break; }
+    try {
+      wt(["-w", "0", "move-focus", backDir]);
+    } catch {
+      break;
+    }
   }
 
   for (let i = 0; i < paneCount; i++) {
@@ -424,7 +466,9 @@ export function focusPane(target, opts = {}) {
   const { zoom = false } = opts;
   tmux(`select-pane -t ${target}`);
   if (zoom) {
-    try { tmux(`resize-pane -t ${target} -Z`); } catch {}
+    try {
+      tmux(`resize-pane -t ${target} -Z`);
+    } catch {}
   }
 }
 
@@ -461,29 +505,49 @@ export function configureTeammateKeybindings(sessionName, opts = {}) {
 
   if (inProcess) {
     // 단일 뷰(zoom) 상태에서 팀메이트 순환
-    tmux(`bind-key -T root -n S-Down if-shell -F '${cond}' ${bindNext} 'send-keys S-Down'`);
-    tmux(`bind-key -T root -n S-Up if-shell -F '${cond}' ${bindPrev} 'send-keys S-Up'`);
+    tmux(
+      `bind-key -T root -n S-Down if-shell -F '${cond}' ${bindNext} 'send-keys S-Down'`,
+    );
+    tmux(
+      `bind-key -T root -n S-Up if-shell -F '${cond}' ${bindPrev} 'send-keys S-Up'`,
+    );
   } else {
     // 분할 뷰에서 팀메이트 순환
-    tmux(`bind-key -T root -n S-Down if-shell -F '${cond}' ${bindNext} 'send-keys S-Down'`);
-    tmux(`bind-key -T root -n S-Up if-shell -F '${cond}' ${bindPrev} 'send-keys S-Up'`);
+    tmux(
+      `bind-key -T root -n S-Down if-shell -F '${cond}' ${bindNext} 'send-keys S-Down'`,
+    );
+    tmux(
+      `bind-key -T root -n S-Up if-shell -F '${cond}' ${bindPrev} 'send-keys S-Up'`,
+    );
   }
 
   // 대체 키: 일부 환경에서 S-Up이 누락될 때 사용
-  tmux(`bind-key -T root -n S-Right if-shell -F '${cond}' ${bindNext} 'send-keys S-Right'`);
-  tmux(`bind-key -T root -n S-Left if-shell -F '${cond}' ${bindPrev} 'send-keys S-Left'`);
-  tmux(`bind-key -T root -n BTab if-shell -F '${cond}' ${bindPrev} 'send-keys BTab'`);
+  tmux(
+    `bind-key -T root -n S-Right if-shell -F '${cond}' ${bindNext} 'send-keys S-Right'`,
+  );
+  tmux(
+    `bind-key -T root -n S-Left if-shell -F '${cond}' ${bindPrev} 'send-keys S-Left'`,
+  );
+  tmux(
+    `bind-key -T root -n BTab if-shell -F '${cond}' ${bindPrev} 'send-keys BTab'`,
+  );
 
   // 현재 활성 pane 인터럽트
-  tmux(`bind-key -T root -n Escape if-shell -F '${cond}' 'send-keys C-c' 'send-keys Escape'`);
+  tmux(
+    `bind-key -T root -n Escape if-shell -F '${cond}' 'send-keys C-c' 'send-keys Escape'`,
+  );
 
   // 태스크 목록 토글 (tmux 3.2+ popup 우선, 실패 시 안내 메시지)
   if (taskListCommand) {
     const escaped = taskListCommand.replace(/'/g, "'\\''");
     try {
-      tmux(`bind-key -T root -n C-t if-shell -F '${cond}' "display-popup -E '${escaped}'" "send-keys C-t"`);
+      tmux(
+        `bind-key -T root -n C-t if-shell -F '${cond}' "display-popup -E '${escaped}'" "send-keys C-t"`,
+      );
     } catch {
-      tmux(`bind-key -T root -n C-t if-shell -F '${cond}' 'display-message "tfx multi tasks 명령으로 태스크 확인"' 'send-keys C-t'`);
+      tmux(
+        `bind-key -T root -n C-t if-shell -F '${cond}' 'display-message "tfx multi tasks 명령으로 태스크 확인"' 'send-keys C-t'`,
+      );
     }
   }
 }
@@ -558,9 +622,7 @@ export function listSessions() {
 
   try {
     const output = tmux('list-sessions -F "#{session_name}"');
-    return output
-      .split("\n")
-      .filter((s) => s.startsWith("tfx-multi-"));
+    return output.split("\n").filter((s) => s.startsWith("tfx-multi-"));
   } catch {
     return [];
   }
@@ -577,7 +639,9 @@ export function getSessionAttachedCount(sessionName) {
   }
 
   try {
-    const output = tmux('list-sessions -F "#{session_name} #{session_attached}"');
+    const output = tmux(
+      'list-sessions -F "#{session_name} #{session_attached}"',
+    );
     const line = output
       .split("\n")
       .find((l) => l.startsWith(`${sessionName} `));