triflux 9.6.0 → 9.7.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "9.6.0",
+  "version": "9.7.0",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "author": {
     "name": "tellang"

package/bin/triflux.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // triflux CLI — setup, doctor, version
 import { copyFileSync, existsSync, readFileSync, readSync, writeFileSync, mkdirSync, chmodSync, readdirSync, unlinkSync, statSync, openSync, closeSync } from "fs";
-import { join, dirname } from "path";
+import { join, dirname, basename } from "path";
 import { homedir } from "os";
 import { execSync, execFileSync, spawn } from "child_process";
 import { fileURLToPath } from "url";
@@ -12,10 +12,19 @@ import { forceCleanupTeam } from "../hub/team/nativeProxy.mjs";
 import { cleanupStaleOmcTeams, inspectStaleOmcTeams } from "../hub/team/staleState.mjs";
 import { getPipelineStateDbPath } from "../hub/pipeline/state.mjs";
 import { ensureGeminiProfiles } from "../scripts/lib/gemini-profiles.mjs";
+import {
+  addRegistryServer,
+  inspectRegistry,
+  inspectRegistryStatus,
+  removeRegistryServer,
+  removeServerFromTargets,
+  syncRegistryTargets,
+} from "../scripts/lib/mcp-guard-engine.mjs";
 import {
   SYNC_MAP, SKILL_ALIASES, REQUIRED_CODEX_PROFILES, LEGACY_CODEX_MODELS,
   syncAliasedSkillDir, hasProfileSection, replaceProfileSection,
   ensureCodexProfiles, getVersion, cleanupStaleSkills, DEPRECATED_SKILLS,
+  extractManagedHookFilename, getManagedRegistryHooks, ensureHooksInSettings,
 } from "../scripts/setup.mjs";
 
 const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -113,6 +122,31 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
       toggle: "특정 훅 활성/비활성 토글: hooks toggle <hookId>",
     },
   },
+  mcp: {
+    usage: "tfx mcp <list|sync|add|remove> [--json]",
+    description: "MCP registry 상태 확인 및 중앙 동기화",
+    subcommands: {
+      list: {
+        usage: "tfx mcp list [--json]",
+        options: [{ name: "--json", type: "boolean", description: "registry + 실제 설정 상태를 JSON으로 출력" }],
+      },
+      sync: {
+        usage: "tfx mcp sync [--json]",
+        options: [{ name: "--json", type: "boolean", description: "동기화 결과를 JSON으로 출력" }],
+      },
+      add: {
+        usage: "tfx mcp add <name> --url <url> [--json]",
+        options: [
+          { name: "--url", type: "string", description: "등록할 MCP URL" },
+          { name: "--json", type: "boolean", description: "등록 결과를 JSON으로 출력" },
+        ],
+      },
+      remove: {
+        usage: "tfx mcp remove <name> [--json]",
+        options: [{ name: "--json", type: "boolean", description: "제거 결과를 JSON으로 출력" }],
+      },
+    },
+  },
   hub: {
     usage: "tfx hub <start|stop|status> [--port N] [--json]",
     description: "tfx-hub 프로세스 제어",
@@ -908,6 +942,135 @@ function addDoctorCheck(report, entry) {
   report.checks.push(entry);
 }
 
+function toHookCoverageName(fileName, fallbackId = "") {
+  if (typeof fileName === "string" && fileName.trim()) {
+    return basename(fileName).replace(/\.mjs$/i, "");
+  }
+  return String(fallbackId || "").replace(/^tfx-/, "");
+}
+
+function computeHookCoverage(settings, managedHooks) {
+  const coverage = {
+    total: managedHooks.length,
+    registered: 0,
+    missing: [],
+  };
+
+  const hooksByEvent = settings?.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
+  for (const spec of managedHooks) {
+    const eventEntries = Array.isArray(hooksByEvent[spec.event]) ? hooksByEvent[spec.event] : [];
+    const found = eventEntries.some((entry) =>
+      Array.isArray(entry?.hooks) &&
+      entry.hooks.some((hook) => extractManagedHookFilename(hook?.command) === spec.fileName),
+    );
+    if (found) {
+      coverage.registered++;
+      continue;
+    }
+    coverage.missing.push(toHookCoverageName(spec.fileName, spec.id));
+  }
+
+  return coverage;
+}
+
+function formatPathForDisplay(filePath) {
+  const value = String(filePath || "").replace(/\\/g, "/");
+  const homePath = homedir().replace(/\\/g, "/");
+  return value.startsWith(homePath) ? `~${value.slice(homePath.length)}` : value;
+}
+
+function renderTable(headers, rows) {
+  if (!rows.length) return;
+  const widths = headers.map((header, index) => {
+    const cellWidths = rows.map((row) => stripAnsi(String(row[index] ?? "")).length);
+    return Math.max(stripAnsi(header).length, ...cellWidths);
+  });
+
+  const padCell = (cell, width) => {
+    const text = String(cell ?? "");
+    return text + " ".repeat(Math.max(0, width - stripAnsi(text).length));
+  };
+  const formatRow = (row) => row.map((cell, index) => padCell(cell, widths[index])).join("  ");
+  console.log(`    ${formatRow(headers)}`);
+  console.log(`    ${widths.map((width) => "─".repeat(width)).join("  ")}`);
+  for (const row of rows) {
+    console.log(`    ${formatRow(row)}`);
+  }
+}
+
+function getOptionValue(args, optionName) {
+  const index = args.indexOf(optionName);
+  if (index === -1) return null;
+  return args[index + 1] ?? null;
+}
+
+function statusBadge(status) {
+  switch (status) {
+    case "present":
+    case "ok":
+    case "removed":
+      return `${GREEN_BRIGHT}${status}${RESET}`;
+    case "updated":
+      return `${AMBER}${status}${RESET}`;
+    case "missing":
+    case "missing-file":
+    case "warning":
+      return `${YELLOW}${status}${RESET}`;
+    case "mismatch":
+    case "invalid":
+    case "invalid-config":
+      return `${RED_BRIGHT}${status}${RESET}`;
+    default:
+      return status;
+  }
+}
+
+function buildMcpStatusRows(statusInfo) {
+  const registryRows = statusInfo.rows
+    .filter((row) => row.type === "registry")
+    .map((row) => {
+      let detail = "";
+      if (row.status === "present") detail = row.actualUrl || row.expectedUrl;
+      else if (row.status === "missing") detail = "registry only";
+      else if (row.status === "missing-file") detail = "config missing";
+      else if (row.status === "mismatch") detail = `expected ${row.expectedUrl}`;
+      else if (row.status === "invalid-config") detail = "parse error";
+      else if (row.status === "stdio") detail = "configured as stdio";
+      return [row.name, row.label, statusBadge(row.status), formatPathForDisplay(row.filePath), detail];
+    });
+
+  const stdioRows = statusInfo.rows
+    .filter((row) => row.type === "stdio")
+    .map((row) => [
+      row.name,
+      row.label,
+      statusBadge("warning"),
+      formatPathForDisplay(row.filePath),
+      row.command ? `stdio: ${row.command}` : "stdio MCP",
+    ]);
+
+  return [...registryRows, ...stdioRows];
+}
+
+function ensureValidRegistryState() {
+  const registryState = inspectRegistry();
+  if (!registryState.exists) {
+    throw createCliError(`MCP registry missing: ${registryState.path}`, {
+      exitCode: EXIT_CONFIG_ERROR,
+      reason: "configError",
+      fix: "config/mcp-registry.json을 복원하거나 `tfx mcp add <name> --url <url>`로 다시 생성하세요.",
+    });
+  }
+  if (!registryState.valid) {
+    throw createCliError(`MCP registry invalid: ${registryState.errors.join("; ")}`, {
+      exitCode: EXIT_CONFIG_ERROR,
+      reason: "configError",
+      fix: `${registryState.path}의 JSON 구조를 수정하세요.`,
+    });
+  }
+  return registryState;
+}
+
 async function cmdDoctor(options = {}) {
   const { fix = false, reset = false, json = false } = options;
   const report = {
@@ -915,6 +1078,7 @@ async function cmdDoctor(options = {}) {
     mode: reset ? "reset" : fix ? "fix" : "check",
     checks: [],
     actions: [],
+    hook_coverage: { total: 0, registered: 0, missing: [] },
     issue_count: 0,
   };
 
@@ -1081,6 +1245,25 @@ async function cmdDoctor(options = {}) {
     } catch {
       warn("웜업 캐시 자동 복구 실패");
     }
+    const registryStateForFix = inspectRegistry();
+    if (registryStateForFix.valid) {
+      try {
+        const mcpSync = syncRegistryTargets({ registry: registryStateForFix.registry });
+        const updatedCount = mcpSync.actions.filter((action) => action.status === "updated").length;
+        const invalidCount = mcpSync.actions.filter((action) => action.status === "invalid-config").length;
+        report.actions.push({ type: "mcp-sync", status: invalidCount > 0 ? "issues" : "ok", actions: mcpSync.actions });
+        if (updatedCount > 0) ok(`MCP registry 동기화: ${updatedCount}개 설정 반영됨`);
+        else info("MCP registry: 이미 최신 상태");
+        if (invalidCount > 0) warn(`MCP registry 동기화 건너뜀: parse error ${invalidCount}개`);
+      } catch (error) {
+        report.actions.push({ type: "mcp-sync", status: "failed", message: error.message });
+        warn(`MCP registry 자동 동기화 실패: ${error.message}`);
+      }
+    } else if (registryStateForFix.exists) {
+      warn("MCP registry invalid — auto sync 건너뜀");
+    } else {
+      info("MCP registry 없음 — auto sync 건너뜀");
+    }
     console.log(`\n  ${LINE}`);
     info("수정 완료 — 아래 진단 결과를 확인하세요");
     console.log("");
@@ -1810,34 +1993,100 @@ async function cmdDoctor(options = {}) {
     }
   }
 
-  // ── Gemini MCP 안전성 ──
-  section("Gemini MCP Safety");
+  // ── MCP 중앙 레지스트리 ──
+  section("MCP Registry");
   {
-    const geminiSettings = join(homedir(), ".gemini", "settings.json");
-    if (existsSync(geminiSettings)) {
-      try {
-        const gs = JSON.parse(readFileSync(geminiSettings, "utf8"));
-        const mcpServers = gs.mcpServers || {};
-        const dangerousServers = Object.keys(mcpServers).filter(name => {
-          const s = mcpServers[name];
-          return s.command && !s.url && name !== "tfx-hub";
-        });
-        if (dangerousServers.length === 0) {
-          addDoctorCheck(report, { name: "gemini-mcp-safety", status: "ok" });
-          ok("stdio MCP 없음 (spawn EPERM 안전)");
-        } else {
-          addDoctorCheck(report, { name: "gemini-mcp-safety", status: "warning", servers: dangerousServers, fix: "~/.gemini/settings.json에서 stdio MCP 제거" });
-          warn(`${dangerousServers.length}개 stdio MCP 감지 — Gemini stall 위험`);
-          for (const s of dangerousServers) info(`  ${s}`);
-          issues++;
+    const registryState = inspectRegistry();
+    if (!registryState.exists) {
+      addDoctorCheck(report, {
+        name: "mcp-registry",
+        status: "missing",
+        path: registryState.path,
+        fix: "config/mcp-registry.json을 복원하거나 `tfx mcp add <name> --url <url>`를 실행하세요.",
+      });
+      warn("mcp-registry.json 없음");
+      info(`path: ${registryState.path}`);
+      issues++;
+    } else if (!registryState.valid) {
+      addDoctorCheck(report, {
+        name: "mcp-registry",
+        status: "invalid",
+        path: registryState.path,
+        errors: registryState.errors,
+        fix: "config/mcp-registry.json 구조를 수정하세요.",
+      });
+      fail("mcp-registry.json invalid");
+      for (const entry of registryState.errors) info(entry);
+      issues++;
+    } else {
+      const statusInfo = inspectRegistryStatus(registryState.registry);
+      const invalidConfigs = statusInfo.configs.filter((config) => config.parseError);
+      const mismatchRows = statusInfo.rows.filter((row) => row.type === "registry" && row.status === "mismatch");
+      const missingRows = statusInfo.rows.filter((row) => row.type === "registry" && row.status === "missing");
+      const missingFileRows = statusInfo.rows.filter((row) => row.type === "registry" && row.status === "missing-file");
+      const stdioRows = statusInfo.rows.filter((row) => row.type === "stdio");
+      const hasHardIssues = invalidConfigs.length > 0 || mismatchRows.length > 0;
+      const status = hasHardIssues
+        ? "issues"
+        : stdioRows.length > 0
+          ? "warning"
+          : "ok";
+
+      addDoctorCheck(report, {
+        name: "mcp-registry",
+        status,
+        path: registryState.path,
+        server_count: Object.keys(registryState.registry.servers || {}).length,
+        rows: statusInfo.rows,
+        invalid_configs: invalidConfigs.map((config) => ({
+          file: config.filePath,
+          error: config.parseError?.message || "parse error",
+        })),
+        ...(stdioRows.length > 0 ? { fix: "tfx doctor --fix 또는 tfx mcp sync" } : {}),
+      });
+
+      ok(`registry 정상 (${Object.keys(registryState.registry.servers || {}).length}개 server)`);
+
+      if (statusInfo.rows.length > 0) {
+        renderTable(
+          ["server", "target", "status", "config", "detail"],
+          buildMcpStatusRows(statusInfo),
+        );
+      } else {
+        info("등록된 MCP server 없음");
+      }
+
+      for (const config of invalidConfigs) {
+        fail(`${config.label}: 설정 파싱 실패`);
+        info(`${formatPathForDisplay(config.filePath)} — ${config.parseError.message}`);
+      }
+
+      for (const row of mismatchRows) {
+        warn(`${row.label}: ${row.name} URL 불일치`);
+        info(`expected ${row.expectedUrl}`);
+        if (row.actualUrl) info(`actual   ${row.actualUrl}`);
+      }
+
+      for (const row of missingFileRows) {
+        info(`${row.label}: ${row.name} 미배치 (${formatPathForDisplay(row.filePath)})`);
+      }
+
+      for (const row of missingRows) {
+        info(`${row.label}: ${row.name} 누락`);
+      }
+
+      if (stdioRows.length === 0) {
+        ok("미등록 stdio MCP 없음");
+      } else {
+        warn(`${stdioRows.length}개 미등록 stdio MCP 감지`);
+        for (const row of stdioRows) {
+          info(`${row.label}: ${row.name}${row.command ? ` (${row.command})` : ""}`);
         }
-      } catch {
-        addDoctorCheck(report, { name: "gemini-mcp-safety", status: "ok" });
-        ok("설정 파일 파싱 불가 — 건너뜀");
       }
-    } else {
-      addDoctorCheck(report, { name: "gemini-mcp-safety", status: "ok" });
-      ok("Gemini 설정 없음 (정상)");
+
+      issues += invalidConfigs.length;
+      issues += mismatchRows.length;
+      issues += stdioRows.length;
     }
   }
 
@@ -1875,6 +2124,93 @@ async function cmdDoctor(options = {}) {
     }
   }
 
+  // ── Hook Coverage (hook-registry vs settings.json) ──
+  section("Hook Coverage");
+  {
+    const registryPath = join(PKG_ROOT, "hooks", "hook-registry.json");
+    const settingsPath = join(CLAUDE_DIR, "settings.json");
+    const managedHooks = getManagedRegistryHooks(registryPath);
+
+    if (managedHooks.length === 0) {
+      addDoctorCheck(report, {
+        name: "hook-coverage",
+        status: "invalid",
+        total: 0,
+        registered: 0,
+        missing: [],
+        fix: "hook-registry.json을 확인하세요.",
+      });
+      warn("hook-registry.json에서 관리 대상 훅을 찾지 못했습니다.");
+      issues++;
+    } else {
+      let settings = {};
+      if (existsSync(settingsPath)) {
+        try {
+          settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+        } catch (error) {
+          const unreadableCoverage = {
+            total: managedHooks.length,
+            registered: 0,
+            missing: managedHooks.map((spec) => toHookCoverageName(spec.fileName, spec.id)),
+          };
+          report.hook_coverage = unreadableCoverage;
+          addDoctorCheck(report, {
+            name: "hook-coverage",
+            status: "invalid",
+            total: unreadableCoverage.total,
+            registered: unreadableCoverage.registered,
+            missing: unreadableCoverage.missing,
+            fix: "settings.json 문법을 수정하거나 tfx setup을 다시 실행하세요.",
+          });
+          fail(`settings.json 파싱 실패: ${error.message}`);
+          issues++;
+          settings = null;
+        }
+      }
+
+      if (settings) {
+        let coverage = computeHookCoverage(settings, managedHooks);
+
+        if (coverage.missing.length > 0 && fix) {
+          const hookFixResult = ensureHooksInSettings({ settingsPath, registryPath });
+          if (hookFixResult.ok) {
+            if (hookFixResult.changed) {
+              ok(`누락 훅 ${hookFixResult.added.length}개 자동 등록됨`);
+            } else {
+              info("누락 훅 자동 등록: 변경 사항 없음");
+            }
+            try {
+              const fixedSettings = JSON.parse(readFileSync(settingsPath, "utf8"));
+              coverage = computeHookCoverage(fixedSettings, managedHooks);
+            } catch (error) {
+              warn(`자동 등록 후 settings.json 재검증 실패: ${error.message}`);
+            }
+          } else {
+            warn(`누락 훅 자동 등록 실패: ${hookFixResult.reason || "unknown_error"}`);
+          }
+        }
+
+        report.hook_coverage = coverage;
+        const coverageStatus = coverage.missing.length === 0 ? "ok" : "issues";
+        addDoctorCheck(report, {
+          name: "hook-coverage",
+          status: coverageStatus,
+          total: coverage.total,
+          registered: coverage.registered,
+          missing: coverage.missing,
+          ...(coverage.missing.length > 0 ? { fix: "tfx doctor --fix 또는 tfx setup" } : {}),
+        });
+
+        if (coverage.missing.length === 0) {
+          ok(`Hook Coverage: ${coverage.registered}/${coverage.total} registered`);
+        } else {
+          fail(`Missing hooks: ${coverage.missing.join(", ")}`);
+          issues += coverage.missing.length;
+        }
+      }
+    }
+  }
+
   // 결과
   console.log(`\n  ${LINE}`);
   if (issues === 0) {
@@ -2198,6 +2534,175 @@ function cmdSchema(args = []) {
   });
 }
 
+function cmdMcp(args = [], options = {}) {
+  const { json = false } = options;
+  const sub = String(args[0] || "list").trim().toLowerCase();
+
+  if (sub === "help" || sub === "--help" || sub === "-h") {
+    console.log(`
+  ${AMBER}${BOLD}⬡ tfx mcp${RESET}
+
+    ${WHITE_BRIGHT}tfx mcp list${RESET}                 ${GRAY}registry + 실제 설정 상태 테이블${RESET}
+    ${WHITE_BRIGHT}tfx mcp sync${RESET}                 ${GRAY}registry 기준 전체 스캔 + 치환${RESET}
+    ${WHITE_BRIGHT}tfx mcp add <name> --url <url>${RESET}    ${GRAY}registry 등록 + 대상 설정 반영${RESET}
+    ${WHITE_BRIGHT}tfx mcp remove <name>${RESET}        ${GRAY}registry + 실제 설정에서 제거${RESET}
+`);
+    return;
+  }
+
+  switch (sub) {
+    case "list": {
+      const registryState = ensureValidRegistryState();
+      const statusInfo = inspectRegistryStatus(registryState.registry);
+      if (json) {
+        printJson({
+          registry_path: registryState.path,
+          server_count: Object.keys(registryState.registry.servers || {}).length,
+          rows: statusInfo.rows,
+          configs: statusInfo.configs.map((config) => ({
+            file: config.filePath,
+            label: config.label,
+            exists: config.exists,
+            parse_error: config.parseError?.message || null,
+          })),
+        });
+        return;
+      }
+
+      console.log(`\n  ${AMBER}${BOLD}⬡ triflux mcp${RESET} ${VER}\n`);
+      console.log(`  ${LINE}`);
+      section("Registry");
+      info(formatPathForDisplay(registryState.path));
+      ok(`${Object.keys(registryState.registry.servers || {}).length}개 server 등록됨`);
+      if (statusInfo.rows.length === 0) {
+        info("표시할 MCP 상태 없음");
+      } else {
+        renderTable(
+          ["server", "target", "status", "config", "detail"],
+          buildMcpStatusRows(statusInfo),
+        );
+      }
+      console.log("");
+      return;
+    }
+
+    case "sync": {
+      const registryState = ensureValidRegistryState();
+      const result = syncRegistryTargets({ registry: registryState.registry });
+      if (json) {
+        printJson({
+          registry_path: registryState.path,
+          actions: result.actions,
+        });
+        return;
+      }
+
+      console.log(`\n  ${AMBER}${BOLD}⬡ triflux mcp sync${RESET} ${VER}\n`);
+      console.log(`  ${LINE}`);
+      section("Actions");
+      for (const action of result.actions) {
+        const label = `${action.label} ${DIM}(${formatPathForDisplay(action.filePath)})${RESET}`;
+        if (action.status === "updated") ok(`${label} → updated`);
+        else if (action.status === "warning") warn(`${label} → warning`);
+        else if (action.status === "invalid-config") fail(`${label} → invalid-config`);
+        else info(`${stripAnsi(label)} → ${action.status}`);
+      }
+      console.log("");
+      return;
+    }
+
+    case "add": {
+      const name = String(args[1] || "").trim();
+      const url = getOptionValue(args, "--url");
+      if (!name) {
+        throw createCliError("MCP server name is required", {
+          exitCode: EXIT_ARG_ERROR,
+          reason: "argError",
+          fix: "tfx mcp add <name> --url <url>",
+        });
+      }
+      if (!url) {
+        throw createCliError("MCP server url is required", {
+          exitCode: EXIT_ARG_ERROR,
+          reason: "argError",
+          fix: "tfx mcp add <name> --url <url>",
+        });
+      }
+
+      const normalizedUrl = (() => {
+        try { return new URL(url).toString(); } catch {
+          throw createCliError(`Invalid MCP URL: ${url}`, {
+            exitCode: EXIT_ARG_ERROR,
+            reason: "argError",
+            fix: "http:// 또는 https:// URL을 사용하세요.",
+          });
+        }
+      })();
+
+      const server = addRegistryServer(name, normalizedUrl);
+      const registryState = ensureValidRegistryState();
+      const syncResult = syncRegistryTargets({ registry: registryState.registry });
+      if (json) {
+        printJson({
+          name,
+          server,
+          actions: syncResult.actions,
+        });
+        return;
+      }
+
+      console.log(`\n  ${AMBER}${BOLD}⬡ triflux mcp add${RESET} ${VER}\n`);
+      console.log(`  ${LINE}`);
+      ok(`${name} 등록됨`);
+      info(normalizedUrl);
+      const updated = syncResult.actions.filter((action) => action.status === "updated").length;
+      info(`동기화 반영: ${updated}개`);
+      console.log("");
+      return;
+    }
+
+    case "remove": {
+      const name = String(args[1] || "").trim();
+      if (!name) {
+        throw createCliError("MCP server name is required", {
+          exitCode: EXIT_ARG_ERROR,
+          reason: "argError",
+          fix: "tfx mcp remove <name>",
+        });
+      }
+
+      ensureValidRegistryState();
+      const removed = removeRegistryServer(name);
+      const cleanup = removeServerFromTargets(name, { targets: removed?.targets });
+      if (json) {
+        printJson({
+          name,
+          removed: Boolean(removed),
+          server: removed,
+          actions: cleanup.actions,
+        });
+        return;
+      }
+
+      console.log(`\n  ${AMBER}${BOLD}⬡ triflux mcp remove${RESET} ${VER}\n`);
+      console.log(`  ${LINE}`);
+      if (removed) ok(`${name} registry에서 제거됨`);
+      else warn(`${name} registry entry 없음`);
+      const changed = cleanup.actions.filter((action) => action.status === "removed").length;
+      info(`설정 제거 반영: ${changed}개`);
+      console.log("");
+      return;
+    }
+
+    default:
+      throw createCliError(`알 수 없는 mcp 서브커맨드: ${sub}`, {
+        exitCode: EXIT_ARG_ERROR,
+        reason: "argError",
+        fix: "tfx mcp help",
+      });
+  }
+}
+
 function checkForUpdate() {
   const cacheFile = join(CLAUDE_DIR, "cache", "triflux-update-check.json");
   const cacheDir = dirname(cacheFile);
@@ -2250,6 +2755,7 @@ ${updateNotice}
     ${DIM}  --fix${RESET}        ${GRAY}진단 + 자동 수정${RESET}
     ${DIM}  --reset${RESET}      ${GRAY}캐시 전체 초기화${RESET}
     ${DIM}  --json${RESET}       ${GRAY}구조화된 진단 결과 JSON 출력${RESET}
+    ${WHITE_BRIGHT}tfx mcp${RESET}        ${GRAY}MCP registry 관리 (list/sync/add/remove)${RESET}
     ${WHITE_BRIGHT}tfx update${RESET}     ${GRAY}최신 안정 버전으로 업데이트${RESET}
     ${DIM}  --dev / dev${RESET}   ${GRAY}dev 태그로 업데이트${RESET}
     ${WHITE_BRIGHT}tfx list${RESET}       ${GRAY}설치된 스킬 목록${RESET}
@@ -2752,6 +3258,9 @@ async function main() {
       await cmdDoctor({ fix, reset, json: JSON_OUTPUT });
       return;
     }
+    case "mcp":
+      cmdMcp(cmdArgs, { json: JSON_OUTPUT });
+      return;
     case "schema":
       cmdSchema(cmdArgs);
       return;

package/hooks/hook-manager.mjs

@@ -12,16 +12,16 @@
 //
 // Claude 대화에서 AskUserQuestion으로 UI를 제공하며 내부적으로 이 명령들을 호출합니다.
 
-import { readFileSync, writeFileSync, existsSync, copyFileSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { PLUGIN_ROOT } from "./lib/resolve-root.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const HOME = process.env.HOME || process.env.USERPROFILE || "";
 const SETTINGS_PATH = join(HOME, ".claude", "settings.json");
 const BACKUP_PATH = join(HOME, ".claude", "settings.hooks-backup.json");
 const REGISTRY_PATH = join(__dirname, "hook-registry.json");
-const ORCHESTRATOR_PATH = join(__dirname, "hook-orchestrator.mjs");
 
 // ── 유틸리티 ────────────────────────────────────────────────
 
@@ -105,9 +105,9 @@ function normalizeCmd(cmd) {
 }
 
 function resolveVars(cmd) {
-  const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || __dirname.replace(/[\\/]hooks$/, "");
   return cmd
-    .replace(/\$\{PLUGIN_ROOT\}/g, pluginRoot)
+    .replace(/\$\{PLUGIN_ROOT\}/g, PLUGIN_ROOT)
+    .replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, PLUGIN_ROOT)
     .replace(/\$\{HOME\}/g, HOME)
     .replace(/\$HOME\b/g, HOME);
 }
@@ -171,7 +171,8 @@ function apply() {
 
   // 오케스트레이터 명령 생성
   const nodeExe = getNodeExe();
-  const orchestratorCmd = `"${nodeExe}" "${ORCHESTRATOR_PATH}"`;
+  const orchestratorPath = "${CLAUDE_PLUGIN_ROOT}/hooks/hook-orchestrator.mjs";
+  const orchestratorCmd = `"${nodeExe}" "${orchestratorPath}"`;
 
   // 모든 이벤트를 하나의 오케스트레이터로 통합
   const newHooks = {};