triflux 10.8.0 → 10.9.0

package/hooks/keyword-rules.json

@@ -190,6 +190,69 @@
       "state": null,
       "mcp_route": null
     },
+    {
+      "id": "wt-tab-route",
+      "patterns": [
+        { "source": "(?:새\\s*탭|탭\\s*(?:새로|추가|생성|열|띄|파|만들))", "flags": "i" },
+        { "source": "(?:패인|화면|pane)\\s*(?:분할|나눠|스플릿|split)", "flags": "i" },
+        { "source": "\\bwt\\b\\s*(?:에\\s*)?(?:탭|tab|열|띄|새)", "flags": "i" },
+        { "source": "(?:터미널|terminal)\\s*(?:탭|새\\s*탭)", "flags": "i" },
+        { "source": "\\b(?:new\\s+tab|split\\s+pane|open\\s+(?:new\\s+)?tab)\\b", "flags": "i" }
+      ],
+      "skill": null,
+      "action": "context_hint",
+      "hint": "WT 탭/패인 생성 요청입니다. wt.exe 직접 호출은 safety-guard가 차단합니다.\n\nhub/team/wt-manager.mjs의 createWtManager() 팩토리로 인스턴스를 만든 뒤 API를 호출하세요:\n- wt.createTab({ title, command, profile, cwd }) — 새 탭\n- wt.splitPane({ direction: 'H'|'V', title, command }) — 패인 분할\n- wt.applySplitLayout([{ title, command, direction }]) — 다중 배치\n- wt.closeTab(title) — 탭 닫기\n\n사용법:\nnode -e \"import('./hub/team/wt-manager.mjs').then(m => { const wt = m.createWtManager(); wt.createTab({ title: 'MyTab', command: 'pwsh' }); })\"",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null
+    },
+    {
+      "id": "wt-tab-rename",
+      "patterns": [
+        { "source": "(?:탭\\s*(?:이름|제목)\\s*(?:바꿔|변경|rename))", "flags": "i" },
+        { "source": "(?:rename\\s+tab|tab\\s+rename)", "flags": "i" }
+      ],
+      "skill": null,
+      "action": "context_hint",
+      "hint": "WT 탭 이름 변경 요청입니다. wt.exe 직접 호출은 safety-guard가 차단합니다.\n\nhub/team/wt-manager.mjs의 createWtManager() 팩토리로 인스턴스를 만든 뒤 API를 호출하세요:\n- wt.renameTab({ oldTitle, newTitle }) — 탭 이름 변경\n\n사용법:\nnode -e \"import('./hub/team/wt-manager.mjs').then(m => { const wt = m.createWtManager(); wt.renameTab({ oldTitle: 'OldName', newTitle: 'NewName' }); })\"",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null
+    },
+    {
+      "id": "wt-tab-list",
+      "patterns": [
+        { "source": "(?:탭\\s*(?:목록|리스트|열린|현재))", "flags": "i" },
+        { "source": "(?:list\\s+tabs|tab\\s+list|열린\\s*탭)", "flags": "i" }
+      ],
+      "skill": null,
+      "action": "context_hint",
+      "hint": "WT 탭 목록 조회 요청입니다. wt.exe 직접 호출은 safety-guard가 차단합니다.\n\nhub/team/wt-manager.mjs의 createWtManager() 팩토리로 인스턴스를 만든 뒤 API를 호출하세요:\n- wt.listTabs() — 현재 열린 탭 목록 (pid 파일 기반)\n\n사용법:\nnode -e \"import('./hub/team/wt-manager.mjs').then(m => { const wt = m.createWtManager(); console.log(wt.listTabs()); })\"",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null
+    },
+    {
+      "id": "wt-tab-close",
+      "patterns": [
+        { "source": "(?:탭\\s*(?:닫아|닫기|종료|정리|close))", "flags": "i" },
+        { "source": "(?:close\\s+tab|tab\\s+close|탭\\s*정리)", "flags": "i" }
+      ],
+      "skill": null,
+      "action": "context_hint",
+      "hint": "WT 탭 닫기 요청입니다. wt.exe 직접 호출은 safety-guard가 차단합니다.\n\nhub/team/wt-manager.mjs의 createWtManager() 팩토리로 인스턴스를 만든 뒤 API를 호출하세요:\n- wt.closeTab(title) — 제목으로 탭 닫기\n- wt.closeStale({ olderThanMs, titlePattern }) — 오래된/패턴 매칭 탭 정리\n\n사용법:\nnode -e \"import('./hub/team/wt-manager.mjs').then(m => { const wt = m.createWtManager(); wt.closeTab('MyTab'); })\"",
+      "priority": 1,
+      "supersedes": ["tfx-unified"],
+      "exclusive": false,
+      "state": null,
+      "mcp_route": null
+    },
     {
       "id": "handoff-route",
       "patterns": [

package/hooks/safety-guard.mjs

@@ -65,7 +65,13 @@ const WT_DIRECT_PATTERNS = [
 ];
 
 const WT_DIRECT_BLOCK_MESSAGE =
-  "[safety-guard] wt.exe 직접 호출 차단됨. → hub/team/wt-manager.mjs의 createTab() / splitPane() / applySplitLayout()을 사용하세요.";
+  "[safety-guard] wt.exe 직접 호출 차단됨.\n" +
+  "→ hub/team/wt-manager.mjs의 createWtManager() 팩토리 사용:\n" +
+  "  wt.createTab({ title, command, profile, cwd })  — 새 탭\n" +
+  "  wt.splitPane({ direction: 'H'|'V', title, command })  — 패인 분할\n" +
+  "  wt.applySplitLayout([{ title, command, direction }])  — 다중 배치\n" +
+  '사용법: node -e "import(\'./hub/team/wt-manager.mjs\').then(m => { const wt = m.createWtManager(); wt.createTab({ title: \'제목\', command: \'pwsh\' }); })"';
+
 
 // ── SSH+PowerShell bash 문법 차단 ────────────────────────────
 // 원격 기본 셸이 PowerShell인 호스트에 bash redirect/glob을 보내면 오동작

package/hub/lib/env-detect.mjs

@@ -0,0 +1,85 @@
+// hub/lib/env-detect.mjs — 쉘/터미널/멀티플렉서 환경 감지
+import { execFileSync } from "node:child_process";
+import { platform as osPlatform } from "node:os";
+
+let _cached = null;
+
+/**
+ * 기본 쉘 감지
+ * Windows: pwsh → powershell
+ * Unix: $SHELL → /bin/sh
+ */
+export function detectShell() {
+  const platform = osPlatform();
+  if (platform === "win32") {
+    try {
+      execFileSync("where", ["pwsh.exe"], { stdio: "ignore", timeout: 3000 });
+      return { name: "pwsh", path: "pwsh.exe", version: null };
+    } catch {
+      try {
+        execFileSync("where", ["powershell.exe"], { stdio: "ignore", timeout: 3000 });
+        return { name: "powershell", path: "powershell.exe", version: null };
+      } catch {
+        return { name: "cmd", path: "cmd.exe", version: null, installHint: "pwsh: winget install Microsoft.PowerShell" };
+      }
+    }
+  }
+
+  const shellPath = process.env.SHELL || "/bin/sh";
+  const name = shellPath.split("/").pop() || "sh";
+  return { name, path: shellPath, version: null };
+}
+
+/**
+ * 터미널 에뮬레이터 감지
+ */
+export function detectTerminal() {
+  const platform = osPlatform();
+  if (platform === "win32") {
+    try {
+      execFileSync("where", ["wt.exe"], { stdio: "ignore", timeout: 3000 });
+      return { name: "windows-terminal", hasWt: true };
+    } catch {
+      return { name: "conhost", hasWt: false, installHint: "Windows Terminal: winget install Microsoft.WindowsTerminal" };
+    }
+  }
+
+  if (process.env.TERM_PROGRAM === "iTerm.app") {
+    return { name: "iterm2", hasWt: false };
+  }
+  if (process.env.TERM_PROGRAM === "Apple_Terminal") {
+    return { name: "terminal-app", hasWt: false };
+  }
+
+  return { name: "unknown", hasWt: false };
+}
+
+/**
+ * 멀티플렉서 감지 (tmux)
+ */
+export function detectMultiplexer() {
+  try {
+    const cmd = osPlatform() === "win32" ? "where" : "which";
+    const path = execFileSync(cmd, ["tmux"], { encoding: "utf8", timeout: 3000, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return { name: "tmux", path };
+  } catch {
+    return { name: "none", path: null };
+  }
+}
+
+/**
+ * 통합 환경 정보 조회 (레이지 싱글톤 캐시)
+ * @returns {{ shell: object, terminal: object, multiplexer: object, platform: string }}
+ */
+export function getEnvironment() {
+  if (_cached) return _cached;
+
+  _cached = Object.freeze({
+    shell: detectShell(),
+    terminal: detectTerminal(),
+    multiplexer: detectMultiplexer(),
+    platform: osPlatform(),
+  });
+
+  return _cached;
+}

package/hub/team/cli/commands/start/start-wt.mjs

@@ -19,7 +19,7 @@ export async function startWtTeam({
     warn(`wt 모드에서 ${layout} 레이아웃은 미지원 — ${effectiveLayout}로 대체`);
   console.log(`  레이아웃: ${effectiveLayout} (${paneCount} panes)`);
 
-  const session = createWtSession(sessionId, {
+  const session = await createWtSession(sessionId, {
     layout: effectiveLayout,
     paneCommands: [
       { title: `${sessionId}-lead`, command: buildCliCommand(lead) },

package/hub/team/conductor.mjs

@@ -28,7 +28,7 @@ import {
 } from "./conductor-registry.mjs";
 import { createEventLog } from "./event-log.mjs";
 import { createHealthProbe } from "./health-probe.mjs";
-import { buildLauncher } from "./launcher-template.mjs";
+import { buildLauncher, getAdapter } from "./launcher-template.mjs";
 import { createRemoteProbe } from "./remote-probe.mjs";
 
 /** 세션 상태 */
@@ -335,7 +335,11 @@ export function createConductor(opts = {}) {
       const backoffMs = Math.min(1000 * 2 ** (session.restarts - 1), 30_000);
       session._respawnTimer = setTimeout(() => {
         session._respawnTimer = null;
-        void respawnSession(session);
+        if (session.config.remote) {
+          startRemoteSession(session);
+        } else {
+          void respawnSession(session);
+        }
       }, backoffMs);
     } else {
       transition(session, STATES.DEAD, `maxRestarts(${maxRestarts})_exceeded`);
@@ -400,6 +404,10 @@ export function createConductor(opts = {}) {
     session.outPath = outPath;
     session.errPath = errPath;
 
+    // 로컬 세션: 프롬프트는 CLI args로 전달되므로 stdin 즉시 닫기
+    // (codex가 stdin pipe 감지 시 "Reading additional input..." 대기 방지)
+    if (child.stdin) child.stdin.end();
+
     eventLog.append("spawn", {
       session: session.id,
       agent: session.config.agent,
@@ -510,40 +518,159 @@ export function createConductor(opts = {}) {
   }
 
   /**
-   * 원격 세션 시작 — child process 대신 SSH capture-pane 폴링.
-   * 원격 세션은 remote-spawn.mjs가 이미 psmux 세션을 생성한 상태를 가정.
+   * 원격 세션 시작 — SSH child process로 직접 실행.
+   * psmux 불필요. 원격 호스트에서 claude -p 를 SSH 경유로 실행하고
+   * 로컬 child process로 관리한다.
    */
   function startRemoteSession(session) {
     transition(session, STATES.STARTING, "remote_initial");
 
-    const { host, paneTarget, sessionName } = session.config;
-    const resolvedPane = paneTarget || `${sessionName || session.id}:0.0`;
-    const resolvedSessionName = sessionName || session.id;
+    const { host, prompt, agent, workdir: remoteWorkdir } = session.config;
+
+    // SSH args를 배열로 구성하여 셸 이스케이프 문제 회피
+    const cdPrefix = remoteWorkdir ? `cd ${remoteWorkdir} && ` : "";
+
+    let remoteBin;
+    if (agent === "claude") {
+      remoteBin = "claude --output-format text";
+    } else if (agent === "gemini") {
+      remoteBin = "gemini -y";
+    } else {
+      remoteBin = "codex exec -s danger-full-access --dangerously-bypass-approvals-and-sandbox";
+    }
+
+    // prompt는 stdin으로 전달 — 셸 이스케이프 문제 완전 회피
+    const sshArgs = [
+      "-o", "ConnectTimeout=30",
+      "-o", "BatchMode=yes",
+      host,
+      `${cdPrefix}${remoteBin}`,
+    ];
+
+    const sshCmd = `ssh ${sshArgs.join(" ")}`;
 
     eventLog.append("remote_start", {
       session: session.id,
       host,
-      paneTarget: resolvedPane,
-      sessionName: resolvedSessionName,
+      command: sshCmd,
     });
 
+    const outPath = join(logsDir, `${session.id}.out.log`);
+    const errPath = join(logsDir, `${session.id}.err.log`);
+    const outWs = createWriteStream(outPath, { flags: "a" });
+    const errWs = createWriteStream(errPath, { flags: "a" });
+
+    let child;
+    try {
+      child = spawn("ssh", sshArgs, {
+        env: process.env,
+        reason: `conductor:remoteSession:${session.id}`,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+      });
+    } catch (err) {
+      eventLog.append("spawn_error", {
+        session: session.id,
+        error: err.message,
+      });
+      handleFailure(session, `spawn_error:${err.message}`);
+      return;
+    }
+
+    session.child = child;
+    session.outPath = outPath;
+    session.errPath = errPath;
     session.alive = true;
 
-    // Remote health probe 설정
-    session.probe?.stop();
-    const probe = createRemoteProbe(
-      {
+    // stdin으로 프롬프트 전달 — 셸 이스케이프 완전 우회
+    if (child.stdin) {
+      child.stdin.write(prompt);
+      child.stdin.end();
+    }
+
+    eventLog.append("spawn", {
+      session: session.id,
+      agent,
+      pid: child.pid,
+      command: sshCmd,
+      remote: true,
+      host,
+    });
+
+    // stdout/stderr 추적
+    let outputBytes = 0;
+    const trackOutput = (buf) => {
+      outputBytes += buf.length;
+    };
+
+    child.stdout?.on("data", (buf) => {
+      trackOutput(buf);
+      outWs.write(buf);
+    });
+    child.stderr?.on("data", (buf) => {
+      trackOutput(buf);
+      errWs.write(buf);
+    });
+
+    // 상태를 healthy로 전이
+    transition(session, STATES.HEALTHY, "remote_ssh_spawned");
+
+    // Health probe — 주기적으로 출력 변화 체크 (F3 stall 감지)
+    let lastBytes = 0;
+    let stallChecks = 0;
+    const stallThreshold = probeOpts.stallChecks || 8; // 8 * intervalMs = stall
+    const healthInterval = setInterval(() => {
+      if (TERMINAL_STATES.has(session.state)) {
+        clearInterval(healthInterval);
+        return;
+      }
+      if (outputBytes > lastBytes) {
+        lastBytes = outputBytes;
+        stallChecks = 0;
+        if (session.state !== STATES.HEALTHY) {
+          transition(session, STATES.HEALTHY, "output_advancing");
+        }
+      } else {
+        stallChecks++;
+        if (stallChecks >= stallThreshold && session.state === STATES.HEALTHY) {
+          transition(session, STATES.STALLED, "remote_no_output");
+        }
+      }
+    }, probeOpts.intervalMs || 5000);
+
+    // exit 핸들러
+    child.once("exit", (code) => {
+      clearInterval(healthInterval);
+      outWs.end();
+      errWs.end();
+      session.alive = false;
+
+      eventLog.append("remote_exit", {
+        session: session.id,
+        code,
+        outputBytes,
         host,
-        paneTarget: resolvedPane,
-        sessionName: resolvedSessionName,
-      },
-      {
-        ...probeOpts,
-        onProbe: (result) => handleProbeResult(session, result),
-      },
-    );
-    session.probe = probe;
-    probe.start();
+      });
+
+      if (code === 0) {
+        transition(session, STATES.COMPLETED, `exit_${code}`);
+        emitter.emit("completed", { sessionId: session.id });
+        maybeAutoShutdown();
+      } else {
+        handleFailure(session, `remote_exit_${code}`);
+      }
+    });
+
+    child.once("error", (err) => {
+      clearInterval(healthInterval);
+      outWs.end();
+      errWs.end();
+      eventLog.append("spawn_error", {
+        session: session.id,
+        error: err.message,
+      });
+      handleFailure(session, `spawn_error:${err.message}`);
+    });
   }
 
   /**

package/hub/team/dashboard-open.mjs

@@ -1,5 +1,3 @@
-import { spawn } from "../lib/spawn-trace.mjs";
-
 import { psmuxExec } from "./psmux.mjs";
 import {
   detectMultiplexer,
@@ -8,6 +6,7 @@ import {
   resolveAttachCommand,
   tmuxExec,
 } from "./session.mjs";
+import { createWtManager } from "./wt-manager.mjs";
 
 function sanitizeWindowTitle(value, fallback = "triflux") {
   const text = String(value || "")
@@ -44,9 +43,10 @@ export function decideDashboardOpenMode({
   return hasWtSession ? "split" : "window";
 }
 
-function spawnWindowsTerminal(spec, opts = {}) {
+async function spawnWindowsTerminal(spec, opts = {}) {
   if (!hasWindowsTerminal()) return false;
 
+  const wt = createWtManager();
   const {
     mode = "window",
     title = "triflux",
@@ -56,35 +56,29 @@ function spawnWindowsTerminal(spec, 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.5;
-  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;
+
+  try {
+    if (mode === "split") {
+      await wt.splitPane({
+        direction: split?.orientation === "V" ? "V" : "H",
+        size: (split?.size || 0.5) * 100,
+        title: safeTitle,
+        cwd: safeCwd,
+        command: spec.args ? `${spec.command} ${spec.args.join(" ")}` : spec.command,
+        profile: "triflux",
+      });
+    } else {
+      await wt.createTab({
+        title: safeTitle,
+        cwd: safeCwd,
+        command: spec.args ? `${spec.command} ${spec.args.join(" ")}` : spec.command,
+        profile: "triflux",
+      });
+    }
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 export function focusManagedPane(target, opts = {}) {
@@ -122,7 +116,7 @@ export function openHeadlessDashboardTarget(sessionName, opts = {}) {
   }
 
   // 전체 열기 (Shift+Enter) → 새 WT 창으로 세션 attach
-  return spawnWindowsTerminal(
+  void spawnWindowsTerminal(
     { command: "psmux", args: ["attach-session", "-t", safeSession] },
     {
       mode: decideDashboardOpenMode({ openAll }),
@@ -130,6 +124,7 @@ export function openHeadlessDashboardTarget(sessionName, opts = {}) {
       cwd,
     },
   );
+  return true;
 }
 
 export function openDashboardRuntimeTarget(runtime, opts = {}) {
@@ -162,11 +157,12 @@ export function openDashboardRuntimeTarget(runtime, opts = {}) {
   try {
     if (!openAll && targetPane)
       focusManagedPane(targetPane, { teammateMode, layout });
-    return spawnWindowsTerminal(resolveAttachCommand(sessionName), {
+    void spawnWindowsTerminal(resolveAttachCommand(sessionName), {
       mode: decideDashboardOpenMode({ openAll }),
       title: title || `▲ ${sanitizeSessionName(sessionName)}`,
       cwd,
     });
+    return true;
   } catch {
     return false;
   }