triflux 10.18.2 → 10.20.0

package/hub/team/terminal-opener.mjs

@@ -0,0 +1,178 @@
+import { exec as defaultExec } from "node:child_process";
+import { platform as osPlatform } from "node:os";
+import { psmuxExec as defaultPsmuxExec } from "./psmux.mjs";
+import { tmuxExec as defaultTmuxExec, detectMultiplexer } from "./session.mjs";
+import { createWtManager as defaultCreateWtManager } from "./wt-manager.mjs";
+
+const TMUX_LIKE_MUXES = new Set(["tmux", "wsl-tmux", "git-bash-tmux"]);
+
+export function sanitizeTerminalTitle(value, fallback = "triflux") {
+  const title = String(value ?? "")
+    .replace(/\s+/gu, " ")
+    .trim();
+  return title || fallback;
+}
+
+export function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+export function powershellSingleQuote(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+export function buildCommandString({ cwd, command }) {
+  const commandString = String(command ?? "");
+  if (!cwd) return commandString;
+  return `cd ${shellQuote(cwd)} && ${commandString}`;
+}
+
+function resolvePlatform(deps) {
+  if (typeof deps.platform === "function") return deps.platform();
+  return deps.platform || osPlatform();
+}
+
+function resolveMux(deps) {
+  if (Object.hasOwn(deps, "mux")) return deps.mux;
+  if (typeof deps.detectMultiplexer === "function")
+    return deps.detectMultiplexer();
+  return detectMultiplexer();
+}
+
+function createTabSpec(spec, title) {
+  return {
+    title,
+    command: String(spec.command ?? ""),
+    cwd: spec.cwd,
+    profile: spec.profile ?? "triflux",
+  };
+}
+
+function execOpenTerminal(execFn) {
+  return new Promise((resolve) => {
+    execFn("open -a Terminal", { timeout: 5000 }, (error) => {
+      resolve(!error);
+    });
+  });
+}
+
+// psmux는 Windows에서 wt-manager 경유 (createTab/splitPane 등) — tmux 호환 unix 명령군과 다른 표면.
+// 비-Windows(macOS/Linux) 환경에서는 psmux가 tmux-compatible new-window/select-pane 명령을 받아주므로
+// tmux 어댑터와 동일하게 취급한다.
+function isTmuxLikeMux(mux, platform) {
+  return TMUX_LIKE_MUXES.has(mux) || (platform !== "win32" && mux === "psmux");
+}
+
+function shellCommandName(value) {
+  const command = String(value);
+  return /^[A-Za-z0-9_./:-]+$/u.test(command) ? command : shellQuote(command);
+}
+
+function buildAttachCommand(mux, sessionName) {
+  if (mux === "psmux") {
+    return `${shellCommandName(process.env.PSMUX_BIN || "psmux")} attach-session -t ${shellQuote(sessionName)}`;
+  }
+  return `tmux attach-session -t ${shellQuote(sessionName)}`;
+}
+
+// wt-manager.createTab은 (a) undefined/void 반환 — legacy success 의미 (b) {success:true|false, ...} 객체 반환의 두 형태가 공존.
+// `result?.success !== false`는 undefined/null/{}을 모두 success로 취급하고 명시적 {success:false}만 실패로 본다.
+function wtResultSucceeded(result) {
+  return result?.success !== false;
+}
+
+export function createTerminalOpener(deps = {}) {
+  const platform = resolvePlatform(deps);
+  const tmuxExec = deps.tmuxExec || defaultTmuxExec;
+  const psmuxExec = deps.psmuxExec || defaultPsmuxExec;
+  const exec = deps.exec || defaultExec;
+  const createWtManager = deps.createWtManager || defaultCreateWtManager;
+
+  async function openCommand(spec = {}) {
+    const title = sanitizeTerminalTitle(spec.title);
+
+    if (platform === "win32") {
+      const wt = createWtManager();
+      try {
+        return wtResultSucceeded(
+          await wt.createTab(createTabSpec(spec, title)),
+        );
+      } catch {
+        return false;
+      }
+    }
+
+    const mux = resolveMux(deps);
+    if (isTmuxLikeMux(mux, platform)) {
+      tmuxExec(
+        `new-window -n ${shellQuote(title)} ${shellQuote(
+          buildCommandString(spec),
+        )}`,
+      );
+      return true;
+    }
+
+    if (platform === "darwin") {
+      return execOpenTerminal(exec);
+    }
+
+    return false;
+  }
+
+  async function openSession(sessionName, opts = {}) {
+    if (platform === "win32") {
+      const wt = createWtManager();
+      try {
+        return wtResultSucceeded(
+          await wt.createTab({
+            title: sanitizeTerminalTitle(opts.title ?? sessionName),
+            command: `psmux attach-session -t ${powershellSingleQuote(sessionName)}`,
+            cwd: opts.cwd,
+            profile: opts.profile ?? "triflux",
+          }),
+        );
+      } catch {
+        return false;
+      }
+    }
+
+    const mux = resolveMux(deps);
+    if (isTmuxLikeMux(mux, platform)) {
+      tmuxExec(
+        `new-window -n ${shellQuote(opts.title ?? sessionName)} ${shellQuote(
+          buildAttachCommand(mux, sessionName),
+        )}`,
+      );
+      return true;
+    }
+
+    return false;
+  }
+
+  function focusPane(sessionName, workerNumber) {
+    const target = `${sessionName}:0.${workerNumber}`;
+    const mux = resolveMux(deps);
+
+    if (mux === "psmux") {
+      psmuxExec(["select-pane", "-t", target]);
+      return true;
+    }
+
+    if (isTmuxLikeMux(mux, platform)) {
+      tmuxExec(`select-pane -t ${shellQuote(target)}`);
+      return true;
+    }
+
+    return false;
+  }
+
+  return { openCommand, openSession, focusPane };
+}
+
+export function openSessionTarget(sessionName, opts = {}) {
+  return createTerminalOpener(opts._deps).openSession(sessionName, opts);
+}
+
+export function focusSessionPane(sessionName, workerNumber, opts = {}) {
+  return createTerminalOpener(opts._deps).focusPane(sessionName, workerNumber);
+}

package/hub/team/worktree-lifecycle.mjs

@@ -4,7 +4,7 @@
 // Remote support: host option → SSH-based git operations via remote-session.mjs.
 
 import { execFile } from "node:child_process";
-import { access, mkdir, readdir, rm } from "node:fs/promises";
+import { access, mkdir, readdir, realpath, rm } from "node:fs/promises";
 import { join, normalize, relative, resolve } from "node:path";
 import { remoteGit, validateHost } from "./remote-session.mjs";
 
@@ -117,6 +117,14 @@ function normPath(p) {
   return normalize(p).replace(/\\/g, "/");
 }
 
+async function normExistingPath(p) {
+  try {
+    return normPath(await realpath(p));
+  } catch {
+    return normPath(p);
+  }
+}
+
 function resolveCleanupTarget(worktreePath, rootDir) {
   const resolvedRoot = resolve(rootDir);
   const resolvedWorktree = resolve(worktreePath);
@@ -562,10 +570,12 @@ export async function pruneOrphanWorktrees({ rootDir = process.cwd() } = {}) {
   try {
     const raw = await git(["worktree", "list", "--porcelain"], rootDir);
     registeredPaths = new Set(
-      raw
-        .split("\n")
-        .filter((l) => l.startsWith("worktree "))
-        .map((l) => normPath(l.slice("worktree ".length))),
+      await Promise.all(
+        raw
+          .split("\n")
+          .filter((l) => l.startsWith("worktree "))
+          .map((l) => normExistingPath(l.slice("worktree ".length))),
+      ),
     );
   } catch {
     return removed; // git worktree list failed → don't remove anything
@@ -573,7 +583,7 @@ export async function pruneOrphanWorktrees({ rootDir = process.cwd() } = {}) {
 
   for (const dir of wtDirs) {
     const fullPath = resolve(swarmDir, dir);
-    const normalized = normPath(fullPath);
+    const normalized = await normExistingPath(fullPath);
     if (!registeredPaths.has(normalized)) {
       try {
         await stopFsmonitorDaemon(fullPath).catch(() => null);

package/hub/team/wt-manager.mjs

@@ -170,12 +170,34 @@ function atomicWriteSync(filePath, data) {
  * @param {number} [opts.tabCreateDelayMs=500]
  * @param {object} [opts.deps] — 테스트용 의존성 주입
  */
+function createNonWindowsStubManager() {
+  const asyncFalse = async () => false;
+  return Object.freeze({
+    ensureWtProfile: () => {},
+    createTab: asyncFalse,
+    renameTab: asyncFalse,
+    closeTab: asyncFalse,
+    listTabs: async () => [],
+    closeStale: async () => 0,
+    createSession: asyncFalse,
+    splitPane: asyncFalse,
+    applySplitLayout: asyncFalse,
+    getEnvironmentInfo: () => ({
+      platform: process.platform,
+      hasWindowsTerminal: false,
+      hasWt: false,
+      isWindowsTerminalSession: false,
+    }),
+    getTabCount: () => 0,
+  });
+}
+
 export function createWtManager(opts = {}) {
   const deps = opts.deps || {};
   const platform = deps.platform || osPlatform;
 
   if (platform() !== "win32") {
-    throw new Error("wt-manager.mjs is Windows-only");
+    return createNonWindowsStubManager();
   }
 
   const now = deps.now || Date.now;

package/hub/workers/codex-mcp.mjs

@@ -16,6 +16,7 @@ const REQUIRED_TOOLS = ["codex", "codex-reply"];
 export { CODEX_MCP_EXECUTION_EXIT_CODE, CODEX_MCP_TRANSPORT_EXIT_CODE };
 export const DEFAULT_CODEX_MCP_TIMEOUT_MS = 10 * 60 * 1000;
 export const DEFAULT_CODEX_MCP_BOOTSTRAP_TIMEOUT_MS = 120 * 1000;
+export const DEFAULT_CODEX_MCP_SHUTDOWN_TIMEOUT_MS = 2_000;
 
 /**
  * Codex MCP transport/bootstrap 계층 오류
@@ -40,6 +41,34 @@ function cloneEnv(env = process.env) {
   );
 }
 
+async function closeWithin(label, closeFn, timeoutMs) {
+  let timer = null;
+  try {
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        resolve({ timedOut: true });
+      }, timeoutMs);
+    });
+    const closed = Promise.resolve()
+      .then(closeFn)
+      .then(() => ({ timedOut: false }));
+    const result = await Promise.race([closed, timeout]);
+    if (result.timedOut) {
+      console.error(
+        `[codex-mcp] WARNING: ${label} did not close within ${timeoutMs}ms; continuing shutdown.`,
+      );
+    }
+    return result;
+  } catch (error) {
+    console.error(
+      `[codex-mcp] WARNING: ${label} close failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return { timedOut: false };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 function collectTextContent(content = []) {
   return content
     .filter((item) => item?.type === "text" && typeof item.text === "string")
@@ -388,7 +417,7 @@ export class CodexMcpWorker {
     this.ready = true;
   }
 
-  async stop() {
+  async stop(options = {}) {
     this.ready = false;
     this.availableTools.clear();
 
@@ -397,10 +426,26 @@ export class CodexMcpWorker {
     this.transport = null;
     this.client = null;
 
+    const shutdownTimeoutMs = Number.isFinite(options.shutdownTimeoutMs)
+      ? options.shutdownTimeoutMs
+      : DEFAULT_CODEX_MCP_SHUTDOWN_TIMEOUT_MS;
+
+    let clientCloseTimedOut = false;
     if (client) {
-      await client.close().catch(() => {});
-    } else if (transport) {
-      await transport.close().catch(() => {});
+      const result = await closeWithin(
+        "client.close",
+        () => client.close(),
+        shutdownTimeoutMs,
+      );
+      clientCloseTimedOut = Boolean(result.timedOut);
+    }
+
+    if (transport && (!client || clientCloseTimedOut)) {
+      await closeWithin(
+        "transport.close",
+        () => transport.close(),
+        shutdownTimeoutMs,
+      );
     }
 
     transport?.stderr?.destroy?.();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.18.2",
+  "version": "10.20.0",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {
@@ -13,29 +13,81 @@
     "tfx-doctor-tui": "bin/tfx-doctor-tui.mjs",
     "tfx-setup-tui": "bin/tfx-setup-tui.mjs"
   },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "@triflux/core": "10.0.1",
-    "@triflux/remote": "^10.0.0-alpha.1"
-  },
   "files": [
     "bin",
+    "tui",
+    "hub",
+    "config",
     "skills",
     "!skills/tfx-workspace",
+    "!**/failure-reports",
+    "scripts",
     "hooks",
     "hud",
-    "scripts",
-    "hub",
     "mesh",
-    "references",
-    "!references/codex-snapshots",
-    "!references/gemini-snapshots",
-    "CLAUDE.md",
+    ".claude-plugin",
     "README.md",
+    "README.ko.md",
     "LICENSE"
   ],
+  "workspaces": [
+    "packages/core",
+    "packages/remote",
+    "packages/triflux"
+  ],
+  "scripts": {
+    "pack": "node scripts/pack.mjs all",
+    "pack:core": "node scripts/pack.mjs core",
+    "pack:remote": "node scripts/pack.mjs remote",
+    "setup": "node scripts/setup.mjs",
+    "preinstall": "node scripts/preinstall.mjs",
+    "postinstall": "node scripts/setup.mjs",
+    "snapshot:codex": "node scripts/snapshot-codex-state.mjs",
+    "snapshot:gemini": "node scripts/snapshot-gemini-state.mjs",
+    "snapshot:all": "npm run snapshot:codex && npm run snapshot:gemini",
+    "lint": "biome check bin config hooks hub hud mesh scripts tests .claude-plugin .github package.json package-lock.json biome.json",
+    "lint:fix": "biome check --write bin config hooks hub hud mesh scripts tests .claude-plugin .github package.json package-lock.json biome.json",
+    "health": "npm test && npm run lint",
+    "test": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 \"tests/**/*.test.mjs\" \"scripts/__tests__/**/*.test.mjs\"",
+    "test:guard-codex-config": "node scripts/check-codex-config-stable.mjs npm test",
+    "test:unit": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 tests/unit/**/*.test.mjs",
+    "test:integration": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 tests/integration/**/*.test.mjs",
+    "test:route-smoke": "node scripts/test-lock.mjs --test scripts/test-tfx-route-no-claude-native.mjs",
+    "test:contract": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 tests/contract/**/*.test.mjs",
+    "test:coverage": "node --experimental-test-coverage --test-coverage-lines=60 --test-coverage-functions=60 --test --test-force-exit --test-concurrency=8 \"tests/**/*.test.mjs\"",
+    "gen:skill-docs": "node scripts/gen-skill-docs.mjs",
+    "gen:skill-manifest": "node scripts/gen-skill-manifest.mjs",
+    "release:check-sync": "node scripts/release/check-sync.mjs",
+    "release:check-sync:fix": "node scripts/release/check-sync.mjs --fix",
+    "release:check-mirror": "node scripts/release/check-packages-mirror.mjs",
+    "release:check-mirror:fix": "node scripts/release/check-packages-mirror.mjs --fix",
+    "release:bump": "node scripts/release/bump-version.mjs",
+    "release:prepare": "node scripts/release/prepare.mjs",
+    "release:publish": "node scripts/release/publish.mjs",
+    "release:verify": "node scripts/release/verify.mjs"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tellang/triflux.git"
+  },
+  "homepage": "https://github.com/tellang/triflux#readme",
+  "author": "tellang",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "better-sqlite3": "^12.6.2",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "systray2": "^2.1.4",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.0.0",
+    "knip": "^6.3.0"
+  },
   "keywords": [
     "claude-code",
     "plugin",
@@ -46,13 +98,5 @@
     "multi-model",
     "triflux",
     "tfx"
-  ],
-  "author": "tellang",
-  "license": "MIT",
-  "homepage": "https://github.com/tellang/triflux#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tellang/triflux.git",
-    "directory": "packages/triflux"
-  }
+  ]
 }

package/scripts/mcp-gateway-ensure.mjs

@@ -3,7 +3,7 @@
 // mcp-gateway-ensure.mjs — SessionStart 훅에서 supergateway MCP 서비스 보장
 // hub-ensure.mjs 패턴을 따름. 가볍게 헬스체크만 수행하고 필요시 기동.
 
-import { execSync } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
@@ -36,10 +36,19 @@ function startGateway() {
   if (!existsSync(scriptPath)) return false;
 
   try {
-    execSync(
-      `powershell -NoProfile -Command "Start-Process -WindowStyle Hidden -FilePath '${process.execPath}' -ArgumentList '${scriptPath.replaceAll("'", "''")}'"`,
-      { stdio: "ignore", timeout: 10000 },
-    );
+    if (process.platform === "win32") {
+      execSync(
+        `powershell -NoProfile -Command "Start-Process -WindowStyle Hidden -FilePath '${process.execPath}' -ArgumentList '${scriptPath.replaceAll("'", "''")}'"`,
+        { stdio: "ignore", timeout: 10000 },
+      );
+    } else {
+      // POSIX: detached node child + stdio:'ignore' so SessionStart 훅이 block 되지 않음
+      const child = spawn(process.execPath, [scriptPath], {
+        detached: true,
+        stdio: "ignore",
+      });
+      child.unref();
+    }
     return true;
   } catch {
     return false;

package/scripts/mcp-gateway-integration-test.mjs

@@ -51,18 +51,34 @@ function runScript(scriptPath, ...args) {
 }
 
 function countSupergateways() {
+  if (process.platform === "win32") {
+    try {
+      // Write the query as a PS1 file to avoid shell quoting issues
+      const ps1 = [
+        `$procs = Get-CimInstance Win32_Process -Filter "Name='node.exe' OR Name='cmd.exe'"`,
+        `$hits = $procs | Where-Object { $_.CommandLine -match 'supergateway' }`,
+        `Write-Output $hits.Count`,
+      ].join("\n");
+      const out = execSync(
+        `powershell -NoProfile -Command "${ps1.replace(/\n/g, "; ")}"`,
+        { encoding: "utf8", timeout: 10000, stdio: ["pipe", "pipe", "ignore"] },
+      );
+      return parseInt(out.trim(), 10) || 0;
+    } catch {
+      return 0;
+    }
+  }
+
+  // POSIX: pgrep -f → 줄별 PID. macOS BSD pgrep 은 `-c` 미지원이라
+  // PID 목록을 받아 줄 수로 카운트한다. 0 match 시 exit 1.
   try {
-    // Write the query as a PS1 file to avoid shell quoting issues
-    const ps1 = [
-      `$procs = Get-CimInstance Win32_Process -Filter "Name='node.exe' OR Name='cmd.exe'"`,
-      `$hits = $procs | Where-Object { $_.CommandLine -match 'supergateway' }`,
-      `Write-Output $hits.Count`,
-    ].join("\n");
-    const out = execSync(
-      `powershell -NoProfile -Command "${ps1.replace(/\n/g, "; ")}"`,
-      { encoding: "utf8", timeout: 10000, stdio: ["pipe", "pipe", "ignore"] },
-    );
-    return parseInt(out.trim(), 10) || 0;
+    const out = execSync("pgrep -f supergateway", {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5000,
+    });
+    const trimmed = out.trim();
+    return trimmed ? trimmed.split("\n").filter(Boolean).length : 0;
   } catch {
     return 0;
   }