triflux 9.3.0 → 9.5.0

package/scripts/lib/cross-review-utils.mjs

@@ -0,0 +1,51 @@
+import { join } from "node:path";
+
+export const SESSION_TTL_SEC = 30 * 60;
+export const STATE_REL_PATH = join(".omc", "state", "cross-review.json");
+
+export function readStdin() {
+  return new Promise((resolve) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", () => resolve(""));
+  });
+}
+
+export function parseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function nowSec() {
+  return Math.floor(Date.now() / 1000);
+}
+
+export function resolveBaseDir(payload) {
+  if (typeof payload?.cwd === "string" && payload.cwd.trim()) return payload.cwd;
+  if (typeof payload?.directory === "string" && payload.directory.trim()) return payload.directory;
+  return process.cwd();
+}
+
+export function shouldTrackPath(filePath) {
+  if (typeof filePath !== "string" || !filePath.trim()) return false;
+
+  const lower = filePath.toLowerCase();
+  if (lower.startsWith(".omc/") || lower.startsWith(".claude/")) return false;
+  if (lower === "package-lock.json" || lower.endsWith("/package-lock.json")) return false;
+  if (/\.(md|lock|yml|yaml)$/i.test(lower)) return false;
+  return true;
+}
+
+export function expectedReviewer(author) {
+  if (author === "claude") return "codex";
+  if (author === "codex") return "claude";
+  if (author === "gemini") return "claude";
+  return "";
+}

package/scripts/lib/hook-utils.mjs

@@ -0,0 +1,14 @@
+export function nudge(message) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      additionalContext: message,
+    },
+  }));
+  process.exit(0);
+}
+
+export function deny(reason) {
+  process.stderr.write(reason);
+  process.exit(2);
+}

package/scripts/lib/mcp-filter.mjs

@@ -369,6 +369,13 @@ function selectContextualServers(baseServers, profile, options = {}) {
   const selected = new Set(
     (profile.alwaysOnServers || []).filter((server) => baseServers.includes(server)),
   );
+  const wantsBrowserObservation = (
+    baseServers.includes('playwright')
+    && /(?:browser|screenshot|layout|responsive|visual|screen|page|ui|ux|regression|캡처|스크린샷|레이아웃|반응형|화면|브라우저)/iu.test(taskText)
+  );
+  if (wantsBrowserObservation) {
+    selected.add('playwright');
+  }
   const requestedSearchTool = typeof options.searchTool === 'string' ? options.searchTool : '';
 
   const rankedServers = rankServers(
@@ -477,7 +484,9 @@ export function resolveAllowedServers(options = {}) {
   const baseServers = availableServers.length
     ? profile.allowedServers.filter((server) => availableServers.includes(server))
     : [...profile.allowedServers];
-  const manifestFiltered = applyManifestFilter(baseServers);
+  const manifestFiltered = availableServers.length
+    ? baseServers
+    : applyManifestFilter(baseServers);
   return selectContextualServers(manifestFiltered, profile, { ...options, inventory, inventoryIndex });
 }
 

package/scripts/psmux-safety-guard.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * psmux-safety-guard.mjs — PreToolUse 훅
+ *
+ * psmux kill-session 직접 호출을 차단하고,
+ * psmux/wt 명령 사용 시 안전 규칙을 강제 주입한다.
+ *
+ * 동작:
+ * - kill-session 직접 호출 → deny (exit 2)
+ * - psmux/wt 명령 감지 → additionalContext에 안전 규칙 주입
+ * - 그 외 → 통과 (exit 0)
+ */
+
+import { nudge, deny } from "./lib/hook-utils.mjs";
+
+const KILL_PATTERN = /\bpsmux\s+kill-session\b/;
+const GRACEFUL_PATTERN = /send-keys.*exit.*Enter[\s\S]*sleep\s+\d/;
+const PSMUX_OR_WT = /\b(psmux|wt\.exe|wt\s)/;
+
+const SAFETY_RULES = `[psmux-safety] WT 프리징 방지 필수 규칙:
+1) exit → sleep 2 → kill 순서 필수. 바로 kill 절대 금지.
+2) psmux send-keys는 PowerShell 구문만 (bash 문법 직접 전달 금지).
+3) 경로는 Windows 형식 (C:\\...). /c/... 금지.
+4) wt.exe는 sp(split-pane)만 사용. nt(new-tab) 금지.
+5) -p triflux 프로파일 필수.`;
+
+async function main() {
+  let raw = "";
+  for await (const chunk of process.stdin) raw += chunk;
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try { input = JSON.parse(raw); } catch { process.exit(0); }
+
+  if (input.tool_name !== "Bash") process.exit(0);
+
+  const cmd = input.tool_input?.command || "";
+
+  // kill-session 직접 호출 감지
+  if (KILL_PATTERN.test(cmd)) {
+    // 같은 명령 블록 안에 graceful exit 패턴이 있으면 허용
+    if (GRACEFUL_PATTERN.test(cmd)) {
+      nudge(SAFETY_RULES);
+    }
+    deny(
+      "[psmux-safety] psmux kill-session 직접 호출 차단.\n" +
+      "WT 프리징을 방지하려면 반드시 exit → sleep 2 → kill 순서를 따르세요.\n\n" +
+      "올바른 패턴:\n" +
+      "  psmux send-keys -t SESSION \"exit\" Enter\n" +
+      "  sleep 2\n" +
+      "  psmux kill-session -t SESSION\n\n" +
+      "이 3줄을 하나의 명령 블록으로 실행하세요."
+    );
+  }
+
+  // psmux/wt 명령 감지 → 안전 규칙 주입
+  if (PSMUX_OR_WT.test(cmd)) {
+    nudge(SAFETY_RULES);
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/scripts/remote-spawn.mjs

@@ -915,48 +915,100 @@ function isPrimaryPaneDead(paneId) {
   }
 }
 
-async function runSpawnCleanupWatcher(sessionName, paneId, timingOptions = {}) {
-  const timings = resolveCleanupWatcherTimingOptions(timingOptions);
-  const startedAt = Date.now();
+async function watchSpawnSessionExit(sessionName, options = {}) {
+  const paneId = options.paneId || `${sessionName}:0.0`;
+  const pollMs = parsePositiveInt(options.pollMs, DEFAULT_CLEANUP_WATCH_POLL_MS);
+  const graceMs = parsePositiveInt(options.graceMs, DEFAULT_CLEANUP_WATCH_GRACE_MS);
+  const maxWaitMs = parsePositiveInt(options.maxWaitMs, DEFAULT_CLEANUP_WATCH_MAX_MS);
+  const sessionExists = typeof options.sessionExists === "function"
+    ? options.sessionExists
+    : psmuxSessionExists;
+  const getPaneStatus = typeof options.getPaneStatus === "function"
+    ? options.getPaneStatus
+    : (targetPaneId) => ({ isDead: isPrimaryPaneDead(targetPaneId), exitCode: null });
+  const killSession = typeof options.killSession === "function"
+    ? options.killSession
+    : killPsmuxSession;
+  const now = typeof options.now === "function" ? options.now : Date.now;
+  const sleep = typeof options.sleep === "function" ? options.sleep : sleepMsAsync;
+  const startedAt = now();
   let consecutiveErrors = 0;
 
-  while (Date.now() - startedAt <= timings.maxMs) {
-    if (!psmuxSessionExists(sessionName)) {
-      return;
+  while (now() - startedAt <= maxWaitMs) {
+    if (!sessionExists(sessionName)) {
+      return { cleaned: false, reason: "session-missing" };
     }
 
-    const dead = isPrimaryPaneDead(paneId);
-    if (dead === null) {
+    const paneStatus = getPaneStatus(paneId) || {};
+    if (paneStatus.isDead == null) {
       consecutiveErrors += 1;
-      if (consecutiveErrors >= 10) return; // psmux 반복 실패 시 조기 종료
+      if (consecutiveErrors >= 10) {
+        return { cleaned: false, reason: "probe-failed" };
+      }
     } else {
       consecutiveErrors = 0;
     }
-    if (dead === true) {
-      await sleepMsAsync(timings.graceMs);
 
-      if (!psmuxSessionExists(sessionName)) {
-        return;
+    if (paneStatus.isDead === true) {
+      await sleep(graceMs);
+
+      if (!sessionExists(sessionName)) {
+        return { cleaned: false, reason: "session-missing" };
       }
 
-      if (isPrimaryPaneDead(paneId) === true) {
-        try { killPsmuxSession(sessionName); } catch {}
-        return;
+      const afterGrace = getPaneStatus(paneId) || {};
+      if (afterGrace.isDead === true) {
+        killSession(sessionName);
+        return {
+          cleaned: true,
+          reason: "pane-dead",
+          exitCode: afterGrace.exitCode ?? paneStatus.exitCode ?? null,
+        };
       }
     }
 
-    await sleepMsAsync(timings.pollMs);
+    await sleep(pollMs);
+  }
+
+  return { cleaned: false, reason: "timeout" };
+}
+
+async function runSpawnCleanupWatcher(sessionName, paneId, timingOptions = {}) {
+  await watchSpawnSessionExit(sessionName, {
+    paneId,
+    pollMs: timingOptions.pollMs,
+    graceMs: timingOptions.graceMs,
+    maxWaitMs: timingOptions.maxMs,
+  });
+}
+
+function startSpawnExitWatcher(sessionName, options = {}) {
+  if (!options.force && !shouldUsePsmux()) {
+    return false;
+  }
+
+  const paneId = options.paneId || `${sessionName}:0.0`;
+  const args = buildSpawnCleanupWatcherArgs(sessionName, paneId, {
+    graceMs: options.graceMs,
+    maxMs: options.maxMs,
+    pollMs: options.pollMs,
+  });
+  args[0] = options.scriptPath || args[0];
+  const spawnFn = typeof options.spawnFn === "function" ? options.spawnFn : spawn;
+  const child = spawnFn(options.execPath || process.execPath, args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  if (child && typeof child.unref === "function") {
+    child.unref();
   }
+  return true;
 }
 
 function startSpawnSessionCleanupWatcher(sessionName, paneId, timingOptions = {}) {
-  const args = buildSpawnCleanupWatcherArgs(sessionName, paneId, timingOptions);
   try {
-    spawn(process.execPath, args, {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true,
-    }).unref();
+    startSpawnExitWatcher(sessionName, { ...timingOptions, force: true, paneId });
   } catch {
     // watcher 시작 실패는 spawn 자체 실패로 보지 않는다.
   }
@@ -1230,6 +1282,8 @@ export const __remoteSpawnTest = {
   buildPromptContext,
   parseArgs,
   rewritePromptPaths,
+  startSpawnExitWatcher,
   stageRemotePromptFiles,
   validateTransferCandidate,
+  watchSpawnSessionExit,
 };

package/scripts/session-spawn-helper.mjs

@@ -69,10 +69,11 @@ export function createIsolatedSession(options = {}) {
 export function attachWithWindowsTerminal(sessionName, options = {}) {
   const profile = options.profile || DEFAULT_ATTACH_PROFILE;
   const title = options.title || sessionName;
+  const spawnFn = options.spawnFn || spawn;
 
   // sp (split-pane), not new-tab
   const wtArgs = ["sp", "-p", profile, "--title", title, "--", "psmux", "attach-session", "-t", sessionName];
-  const child = spawn("wt.exe", wtArgs, { detached: true, stdio: "ignore", windowsHide: false });
+  const child = spawnFn("wt.exe", wtArgs, { detached: true, stdio: "ignore", windowsHide: false });
   child.unref();
   return wtArgs;
 }
@@ -154,7 +155,7 @@ async function main() {
   }
 
   if (!hasPsmux()) {
-    process.stderr.write("ERROR: psmux가 설치되어 있지 않습니다. npm install -g psmux\n");
+    process.stderr.write("ERROR: psmux 미설치. 설치: winget install marlocarlo.psmux (또는 npm i -g psmux)\n");
     process.exit(1);
   }
 

package/scripts/setup.mjs

@@ -4,7 +4,7 @@
 // - hud-qos-status.mjs를 ~/.claude/hud/에 동기화
 // - skills/를 ~/.claude/skills/에 동기화
 
-import { copyFileSync, mkdirSync, readFileSync, writeFileSync, readdirSync, existsSync, chmodSync, unlinkSync } from "fs";
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync, readdirSync, existsSync, chmodSync, unlinkSync, rmSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { spawn, execFileSync } from "child_process";
@@ -52,6 +52,7 @@ const REQUIRED_CODEX_PROFILES = [
       'model = "gpt-5.3-codex-spark"',
       'model_reasoning_effort = "low"',
     ],
+    proOnly: true, // Pro 플랜 전용 — Plus/기본에서는 미동작
   },
 ];
 
@@ -62,6 +63,54 @@ const SKILL_ALIASES = [
   },
 ];
 
+/** 패키지에서 제거된 스킬 목록 — setup/update 시 ~/.claude/skills/에서 자동 삭제 */
+const DEPRECATED_SKILLS = [
+  "tfx-eval",
+  "tfx-learn",
+  "tfx-wrapup",
+];
+
+/** 마이그레이션 대상 구형 Codex 모델 — 이 모델을 사용하는 프로필을 감지하여 안내 */
+const LEGACY_CODEX_MODELS = ["o4-mini", "o3", "o3-pro", "o1", "o1-mini", "o1-pro", "gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano", "codex-mini-latest"];
+
+/**
+ * ~/.claude/skills/ 에서 패키지에 없는 stale tfx-* 스킬을 제거한다.
+ * @param {string} skillsDst - ~/.claude/skills/ 경로
+ * @param {string} skillsSrc - 패키지의 skills/ 경로
+ * @returns {{ removed: string[], count: number }}
+ */
+function cleanupStaleSkills(skillsDst, skillsSrc) {
+  const removed = [];
+  if (!existsSync(skillsDst)) return { removed, count: 0 };
+
+  const packageSkills = new Set();
+  if (existsSync(skillsSrc)) {
+    for (const name of readdirSync(skillsSrc)) {
+      packageSkills.add(name);
+    }
+  }
+  // aliases도 유효한 스킬로 등록
+  for (const { alias } of SKILL_ALIASES) {
+    packageSkills.add(alias);
+  }
+
+  for (const name of readdirSync(skillsDst)) {
+    // tfx- 접두사가 아닌 스킬은 사용자 커스텀 — 건드리지 않음
+    if (!name.startsWith("tfx-")) continue;
+    if (packageSkills.has(name)) continue;
+
+    // 패키지에 없는 tfx-* 스킬 → 삭제
+    const skillDir = join(skillsDst, name);
+    try {
+      rmSync(skillDir, { recursive: true, force: true });
+      removed.push(name);
+    } catch {
+      // 삭제 실패 시 무시
+    }
+  }
+  return { removed, count: removed.length };
+}
+
 function buildAliasedSkillContent(srcContent, { alias, source }) {
   return srcContent
     .replace(/^name:\s*.+$/m, `name: ${alias}`)
@@ -141,6 +190,11 @@ const SYNC_MAP = [
     dst: join(CLAUDE_DIR, "scripts", "hub", "workers", "claude-worker.mjs"),
     label: "hub/workers/claude-worker.mjs",
   },
+  {
+    src: join(PLUGIN_ROOT, "hub", "workers", "worker-utils.mjs"),
+    dst: join(CLAUDE_DIR, "scripts", "hub", "workers", "worker-utils.mjs"),
+    label: "hub/workers/worker-utils.mjs",
+  },
   {
     src: join(PLUGIN_ROOT, "hub", "workers", "factory.mjs"),
     dst: join(CLAUDE_DIR, "scripts", "hub", "workers", "factory.mjs"),
@@ -216,6 +270,26 @@ const SYNC_MAP = [
     dst: join(CLAUDE_DIR, "scripts", "lib", "mcp-server-catalog.mjs"),
     label: "lib/mcp-server-catalog.mjs",
   },
+  {
+    src: join(PLUGIN_ROOT, "scripts", "lib", "mcp-manifest.mjs"),
+    dst: join(CLAUDE_DIR, "scripts", "lib", "mcp-manifest.mjs"),
+    label: "lib/mcp-manifest.mjs",
+  },
+  {
+    src: join(PLUGIN_ROOT, "scripts", "lib", "hook-utils.mjs"),
+    dst: join(CLAUDE_DIR, "scripts", "lib", "hook-utils.mjs"),
+    label: "lib/hook-utils.mjs",
+  },
+  {
+    src: join(PLUGIN_ROOT, "scripts", "psmux-safety-guard.mjs"),
+    dst: join(CLAUDE_DIR, "scripts", "psmux-safety-guard.mjs"),
+    label: "psmux-safety-guard.mjs",
+  },
+  {
+    src: join(PLUGIN_ROOT, "scripts", "lib", "cross-review-utils.mjs"),
+    dst: join(CLAUDE_DIR, "scripts", "lib", "cross-review-utils.mjs"),
+    label: "lib/cross-review-utils.mjs",
+  },
   {
     src: join(PLUGIN_ROOT, "scripts", "lib", "keyword-rules.mjs"),
     dst: join(CLAUDE_DIR, "scripts", "lib", "keyword-rules.mjs"),
@@ -331,13 +405,20 @@ function ensureCodexProfiles() {
       writeFileSync(CODEX_CONFIG_PATH, updated, "utf8");
     }
 
-    return changed;
-  } catch {
-    return 0;
+    return { ok: true, changed };
+  } catch (error) {
+    return { ok: false, changed: 0, message: error.message };
   }
 }
 
-export { replaceProfileSection, hasProfileSection, detectDevMode, SYNC_MAP, BREADCRUMB_PATH, PLUGIN_ROOT, CLAUDE_DIR, SKILL_ALIASES };
+export {
+  replaceProfileSection, hasProfileSection, escapeRegExp, detectDevMode,
+  SYNC_MAP, BREADCRUMB_PATH, PLUGIN_ROOT, CLAUDE_DIR,
+  SKILL_ALIASES, REQUIRED_CODEX_PROFILES,
+  DEPRECATED_SKILLS, LEGACY_CODEX_MODELS,
+  buildAliasedSkillContent, syncAliasedSkillDir, getVersion, ensureCodexProfiles,
+  cleanupStaleSkills,
+};
 
 async function main() {
 const isSync = process.argv.includes("--sync");
@@ -739,24 +820,49 @@ if (existsSync(HUB_PID_FILE)) {
 }
 
 // ── psmux 자동 설치 (Windows, headless 모드용) ──
+// psmux: Windows용 터미널 멀티플렉서. Codex/Gemini CLI를 병렬 세션으로 실행할 때 필요.
+// 없어도 triflux 기본 기능은 동작하지만, headless 멀티모델 오케스트레이션이 비활성화됨.
 
+let psmuxInstalled = false;
 if (process.platform === "win32") {
   try {
     execFileSync("where", ["psmux"], { stdio: "ignore" });
+    psmuxInstalled = true;
   } catch {
     // psmux 미설치 — winget으로 자동 설치 시도
-    console.log("  psmux 미설치 — winget으로 설치 중...");
+    console.log("  psmux 미설치 — 자동 설치 시도 중...");
     try {
       execFileSync("winget", ["install", "--id", "marlocarlo.psmux", "--accept-package-agreements", "--accept-source-agreements"], {
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 60000,
       });
       console.log("  \x1b[32m✓\x1b[0m psmux 설치 완료");
+      psmuxInstalled = true;
       synced++;
     } catch {
-      console.log("  \x1b[33m⚠\x1b[0m psmux 자동 설치 실패 — 수동 설치: winget install psmux");
+      console.log([
+        "  \x1b[33m⚠\x1b[0m psmux 자동 설치 실패 — 수동 설치 방법:",
+        "    \x1b[36m옵션 1:\x1b[0m winget install marlocarlo.psmux",
+        "    \x1b[36m옵션 2:\x1b[0m scoop install psmux",
+        "    \x1b[36m옵션 3:\x1b[0m npm install -g psmux",
+        "  \x1b[2m(없어도 기본 기능은 동작합니다 — 멀티모델 병렬 실행만 비활성화)\x1b[0m",
+      ].join("\n"));
     }
   }
+} else {
+  // non-Windows: tmux 사용 (psmux 불필요)
+  psmuxInstalled = true;
+}
+
+// ── stale 스킬 정리 (패키지에서 제거된 tfx-* 스킬 삭제) ──
+{
+  const skillsDst = join(CLAUDE_DIR, "skills");
+  const skillsSrc = join(PLUGIN_ROOT, "skills");
+  const cleanup = cleanupStaleSkills(skillsDst, skillsSrc);
+  if (cleanup.count > 0) {
+    console.log(`  \x1b[32m✓\x1b[0m ${cleanup.count}개 구형 스킬 제거: ${cleanup.removed.join(", ")}`);
+    synced++;
+  }
 }
 
 // ── HUD 에러 캐시 자동 클리어 (업데이트/재설치 시) ──
@@ -814,8 +920,8 @@ if (process.platform === "win32") {
 
 // ── Codex 프로필 자동 보정 ──
 
-const codexProfilesAdded = ensureCodexProfiles();
-if (codexProfilesAdded > 0) {
+const codexProfileResult = ensureCodexProfiles();
+if (codexProfileResult.changed > 0) {
   synced++;
 }
 
@@ -877,6 +983,7 @@ ${B}╚════════════════════════
   ${G}✓${R} hud-qos-status   → ~/.claude/hud/
   ${G}✓${R} ${synced > 0 ? synced + " files synced" : "all files up to date"}
   ${G}✓${R} HUD statusLine   → settings.json
+  ${psmuxInstalled ? `${G}✓${R} psmux            → headless 멀티모델 오케스트레이션` : `${Y}○${R} psmux 미설치     → ${D}winget install marlocarlo.psmux${R} ${D}(선택)${R}`}
 
 ${B}Commands:${R}
   ${C}triflux${R} setup     파일 동기화 + HUD 설정
@@ -900,6 +1007,19 @@ ${B}Skills (Claude Code):${R}
 ${Y}!${R} 세션 재시작 후 스킬이 활성화됩니다
 ${D}https://github.com/tellang/triflux${R}
 `);
+
+  // ── GitHub Star 체크 (비인터랙티브 — postinstall에서는 confirm 불가) ──
+  try {
+    execFileSync("gh", ["auth", "status"], { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+    try {
+      execFileSync("gh", ["api", "user/starred/tellang/triflux"], { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      console.log(`  ${G}⭐${R} 이미 함께하고 계시군요.`);
+    } catch {
+      console.log(`  ${Y}⭐${R} 하나가 큰 차이를 만듭니다. ${D}https://github.com/tellang/triflux${R}`);
+    }
+  } catch {
+    // gh 미설치/미인증 — 무시
+  }
 }
 
 process.exit(0);