@triflux/core 10.50.1 → 10.51.0

package/hub/lib/mcp-response-cache.mjs

@@ -1,239 +0,0 @@
-// hub/lib/mcp-response-cache.mjs — MCP 응답 캐시 (LRU + TTL)
-// Deep 스킬에서 3개 모델이 같은 context7 문서를 요청하면 1번만 호출, 나머지는 캐시 hit.
-// 파일 기반 영속 + 메모리 기반 핫캐시 이중 구조.
-
-import { createHash } from "node:crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-const DEFAULT_CACHE_DIR = join(homedir(), ".triflux", "mcp-cache");
-const DEFAULT_MAX_ENTRIES = 500;
-
-// 서버별 TTL (ms)
-const SERVER_TTL = Object.freeze({
-  context7: 60 * 60 * 1000, // 1시간 — 라이브러리 문서는 자주 안 바뀜
-  "brave-search": 10 * 60 * 1000, // 10분 — 웹 검색
-  exa: 10 * 60 * 1000, // 10분
-  tavily: 10 * 60 * 1000, // 10분
-  serena: 5 * 60 * 1000, // 5분 — 코드 분석 (코드 변경 가능)
-  jira: 2 * 60 * 1000, // 2분 — 이슈 상태 자주 변경
-  notion: 5 * 60 * 1000, // 5분
-  _default: 5 * 60 * 1000, // 기본 5분
-});
-
-function hashKey(server, method, params) {
-  const payload = JSON.stringify({ server, method, params });
-  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
-}
-
-/**
- * MCP 응답 캐시 생성.
- * @param {object} [opts]
- * @param {string} [opts.cacheDir] — 캐시 디렉토리
- * @param {number} [opts.maxEntries] — 최대 엔트리 수 (LRU)
- * @returns {McpResponseCache}
- */
-export function createMcpResponseCache(opts = {}) {
-  const cacheDir = opts.cacheDir || DEFAULT_CACHE_DIR;
-  const maxEntries = opts.maxEntries || DEFAULT_MAX_ENTRIES;
-
-  mkdirSync(cacheDir, { recursive: true });
-
-  // 메모리 핫캐시 (Map — insertion order = LRU)
-  const hot = new Map();
-
-  let hits = 0;
-  let misses = 0;
-
-  function getTtl(server) {
-    return SERVER_TTL[server] || SERVER_TTL._default;
-  }
-
-  function getCachePath(key) {
-    return join(cacheDir, `${key}.json`);
-  }
-
-  /**
-   * 캐시 조회.
-   * @param {string} server — MCP 서버 이름
-   * @param {string} method — MCP 메서드
-   * @param {*} params — 요청 파라미터
-   * @returns {{ hit: boolean, data?: * }}
-   */
-  function get(server, method, params) {
-    const key = hashKey(server, method, params);
-    const ttl = getTtl(server);
-
-    // 1) 메모리 핫캐시
-    if (hot.has(key)) {
-      const entry = hot.get(key);
-      if (Date.now() - entry.ts < ttl) {
-        hits++;
-        // LRU: 삭제 후 재삽입 (Map은 insertion order)
-        hot.delete(key);
-        hot.set(key, entry);
-        return { hit: true, data: entry.data };
-      }
-      hot.delete(key);
-    }
-
-    // 2) 파일 캐시
-    const path = getCachePath(key);
-    if (existsSync(path)) {
-      try {
-        const entry = JSON.parse(readFileSync(path, "utf8"));
-        if (Date.now() - entry.ts < ttl) {
-          hits++;
-          hot.set(key, entry);
-          evictIfNeeded();
-          return { hit: true, data: entry.data };
-        }
-        // expired — 삭제
-        try {
-          unlinkSync(path);
-        } catch {
-          /* ignore */
-        }
-      } catch {
-        /* corrupt file */
-      }
-    }
-
-    misses++;
-    return { hit: false };
-  }
-
-  /**
-   * 캐시 저장.
-   * @param {string} server
-   * @param {string} method
-   * @param {*} params
-   * @param {*} data — 응답 데이터
-   */
-  function set(server, method, params, data) {
-    const key = hashKey(server, method, params);
-    const entry = { ts: Date.now(), server, method, data };
-
-    // 메모리
-    hot.set(key, entry);
-    evictIfNeeded();
-
-    // 파일
-    try {
-      writeFileSync(getCachePath(key), JSON.stringify(entry), "utf8");
-    } catch {
-      /* best-effort */
-    }
-  }
-
-  function evictIfNeeded() {
-    while (hot.size > maxEntries) {
-      const oldest = hot.keys().next().value;
-      hot.delete(oldest);
-    }
-  }
-
-  /**
-   * 만료된 파일 캐시 정리.
-   * @returns {number} 삭제된 파일 수
-   */
-  function prune() {
-    let pruned = 0;
-    try {
-      for (const name of readdirSync(cacheDir)) {
-        if (!name.endsWith(".json")) continue;
-        const path = join(cacheDir, name);
-        try {
-          const entry = JSON.parse(readFileSync(path, "utf8"));
-          const ttl = getTtl(entry.server || "_default");
-          if (Date.now() - entry.ts >= ttl) {
-            unlinkSync(path);
-            pruned++;
-          }
-        } catch {
-          // corrupt — 삭제
-          try {
-            unlinkSync(path);
-            pruned++;
-          } catch {
-            /* ignore */
-          }
-        }
-      }
-    } catch {
-      /* ignore */
-    }
-    return pruned;
-  }
-
-  /**
-   * 캐시 통계.
-   * @returns {{ hits, misses, hotSize, diskFiles, hitRate }}
-   */
-  function stats() {
-    let diskFiles = 0;
-    try {
-      diskFiles = readdirSync(cacheDir).filter((n) =>
-        n.endsWith(".json"),
-      ).length;
-    } catch {
-      /* ignore */
-    }
-
-    const total = hits + misses;
-    return {
-      hits,
-      misses,
-      hotSize: hot.size,
-      diskFiles,
-      hitRate: total > 0 ? `${((hits / total) * 100).toFixed(1)}%` : "0%",
-    };
-  }
-
-  /** 전체 캐시 초기화. */
-  function clear() {
-    hot.clear();
-    try {
-      for (const name of readdirSync(cacheDir)) {
-        if (name.endsWith(".json")) {
-          try {
-            unlinkSync(join(cacheDir, name));
-          } catch {
-            /* ignore */
-          }
-        }
-      }
-    } catch {
-      /* ignore */
-    }
-    hits = 0;
-    misses = 0;
-  }
-
-  return Object.freeze({
-    get,
-    set,
-    prune,
-    stats,
-    clear,
-    get cacheDir() {
-      return cacheDir;
-    },
-  });
-}
-
-// 싱글톤 인스턴스 (Hub 프로세스 내에서 공유)
-let _instance = null;
-
-export function getMcpResponseCache(opts) {
-  if (!_instance) _instance = createMcpResponseCache(opts);
-  return _instance;
-}

package/hub/lib/path-utils.mjs

@@ -1,165 +0,0 @@
-// hub/lib/path-utils.mjs — Windows/POSIX 경로 변환 유틸리티
-
-/**
- * Windows 경로를 Git Bash 스타일 POSIX 경로로 변환한다.
- * C:\foo\bar → /c/foo/bar
- * 이미 POSIX 경로면 그대로 반환.
- * null/undefined → 빈 문자열
- * @param {string|null|undefined} windowsPath
- * @returns {string}
- */
-export function toPosixPath(windowsPath) {
-  if (windowsPath == null) return "";
-  const p = String(windowsPath);
-  if (!p) return "";
-
-  // 이미 POSIX 경로 (/ 로 시작하거나 드라이브 레터 없음)
-  const winDriveMatch = p.match(/^([A-Za-z]):[/\\](.*)/);
-  if (!winDriveMatch) {
-    // 백슬래시만 있는 상대 경로도 forward slash로 변환
-    return p.replace(/\\/g, "/");
-  }
-
-  const drive = winDriveMatch[1].toLowerCase();
-  const rest = winDriveMatch[2].replace(/\\/g, "/");
-  return `/${drive}/${rest}`;
-}
-
-/**
- * POSIX 경로(Git Bash 스타일)를 Windows 경로로 변환한다.
- * /c/foo/bar → C:\foo\bar
- * 이미 Windows 경로면 그대로 반환.
- * null/undefined → 빈 문자열
- * @param {string|null|undefined} posixPath
- * @returns {string}
- */
-export function toWindowsPath(posixPath) {
-  if (posixPath == null) return "";
-  const p = String(posixPath);
-  if (!p) return "";
-
-  // 이미 Windows 경로
-  if (/^[A-Za-z]:/.test(p)) {
-    return p.replace(/\//g, "\\");
-  }
-
-  // Git Bash 스타일: /c/foo/bar
-  const gitBashMatch = p.match(/^\/([a-zA-Z])(\/.*)?$/);
-  if (gitBashMatch) {
-    const drive = gitBashMatch[1].toUpperCase();
-    const rest = gitBashMatch[2] ? gitBashMatch[2].replace(/\//g, "\\") : "\\";
-    return `${drive}:${rest}`;
-  }
-
-  return p;
-}
-
-/**
- * 현재 OS에 맞게 경로를 정규화한다.
- * win32: backslash, 그 외: forward slash
- * @param {string|null|undefined} p
- * @returns {string}
- */
-export function normalizePath(p) {
-  if (p == null) return "";
-  const str = String(p);
-  if (process.platform === "win32") {
-    return str.replace(/\//g, "\\");
-  }
-  return str.replace(/\\/g, "/");
-}
-
-/**
- * 쉘 타입에 맞는 경로로 변환한다.
- * @param {string|null|undefined} path
- * @param {'git-bash'|'wsl'|'cmd'|'powershell'} shellType
- * @returns {string}
- */
-export function resolveShellPath(path, shellType) {
-  if (path == null) return "";
-  const p = String(path);
-
-  switch (shellType) {
-    case "git-bash":
-      return toPosixPath(p);
-
-    case "wsl": {
-      // Git Bash 경로를 먼저 Windows로 변환 후 WSL 형식으로
-      const winPath = /^[A-Za-z]:/.test(p) ? p : toWindowsPath(p);
-      const wslDriveMatch = winPath.match(/^([A-Za-z]):[/\\](.*)/);
-      if (wslDriveMatch) {
-        const drive = wslDriveMatch[1].toLowerCase();
-        const rest = wslDriveMatch[2].replace(/\\/g, "/");
-        return rest ? `/mnt/${drive}/${rest}` : `/mnt/${drive}`;
-      }
-      // 이미 /mnt/ 형식이면 그대로
-      if (p.startsWith("/mnt/")) return p;
-      return p.replace(/\\/g, "/");
-    }
-
-    case "cmd":
-    case "powershell":
-      return toWindowsPath(p);
-
-    default:
-      return p;
-  }
-}
-
-/**
- * 환경 변수와 플랫폼 정보로 현재 쉘 타입을 추론한다.
- * @returns {'git-bash'|'wsl'|'cmd'|'powershell'|'unix'}
- */
-export function detectShellType() {
-  // WSL 감지: WSL_DISTRO_NAME 또는 WSLENV
-  if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) {
-    return "wsl";
-  }
-
-  // Windows 플랫폼
-  if (process.platform === "win32") {
-    const shell = process.env.SHELL || "";
-    const term = process.env.TERM || "";
-    const msystem = process.env.MSYSTEM || "";
-
-    // Git Bash 감지: SHELL=/usr/bin/bash + MSYSTEM=MINGW64 등
-    if (
-      shell.includes("bash") ||
-      msystem.startsWith("MINGW") ||
-      msystem.startsWith("MSYS") ||
-      term === "xterm"
-    ) {
-      return "git-bash";
-    }
-
-    // PowerShell 감지
-    if (process.env.PSModulePath || process.env.PSHOME) {
-      return "powershell";
-    }
-
-    return "cmd";
-  }
-
-  // 비-Windows
-  return "unix";
-}
-
-/**
- * WSL 경로 여부를 확인한다 (/mnt/ 시작).
- * @param {string|null|undefined} p
- * @returns {boolean}
- */
-export function isWslPath(p) {
-  if (p == null) return false;
-  return String(p).startsWith("/mnt/");
-}
-
-/**
- * Git Bash 경로 여부를 확인한다 (/c/ 또는 /d/ 등 단일 소문자 드라이브 레터).
- * @param {string|null|undefined} p
- * @returns {boolean}
- */
-export function isGitBashPath(p) {
-  if (p == null) return false;
-  return /^\/[a-zA-Z](\/|$)/.test(String(p));
-}

package/hub/lib/risk-tier.mjs

@@ -1,53 +0,0 @@
-export const HIGH_PATTERNS = Object.freeze([
-  /^hub\//,
-  /^scripts\//,
-  /^\.claude\/rules\//,
-  /^bin\//,
-  /^\.github\//,
-]);
-
-export const MEDIUM_PATTERNS = Object.freeze([
-  /package\.json$/,
-  /\.ya?ml$/,
-  /\.toml$/,
-  /^config\//,
-  /^hooks\//,
-]);
-
-export const LOW_PATTERNS = Object.freeze([/\.md$/, /\.txt$/, /\.test\./]);
-
-export function classifyRiskTier({ changedFiles }) {
-  const files = Array.isArray(changedFiles)
-    ? changedFiles.filter((file) => typeof file === "string" && file.length > 0)
-    : [];
-
-  if (files.length === 0) {
-    return "low";
-  }
-
-  if (matchesAny(files, HIGH_PATTERNS)) {
-    return "high";
-  }
-
-  if (files.length > 1) {
-    return "medium";
-  }
-
-  if (matchesAny(files, MEDIUM_PATTERNS)) {
-    return "medium";
-  }
-
-  if (matchesPattern(files[0], LOW_PATTERNS)) {
-    return "low";
-  }
-
-  return "medium";
-}
-
-function matchesAny(files, patterns) {
-  return files.some((file) => matchesPattern(file, patterns));
-}
-
-function matchesPattern(file, patterns) {
-  return patterns.some((pattern) => pattern.test(file));
-}

package/hub/lib/ssh-command.mjs

@@ -1,231 +0,0 @@
-// hub/lib/ssh-command.mjs — OS-aware SSH command builder
-// PowerShell 호스트에 bash 문법(2>/dev/null, &&, $())을 보내는 사고를 방지한다.
-// 모든 SSH 명령 생성 코드에서 이 유틸리티를 사용할 것.
-
-import { readHost, readHosts, resolveHost } from "./hosts-compat.mjs";
-
-/** hosts.json 캐시 (프로세스 수명 동안 유지) */
-let hostsCache = null;
-let hostsCacheRoot = null;
-
-/**
- * hosts.json을 로드하여 캐시한다.
- * @param {string} [repoRoot] — 프로젝트 루트 경로
- */
-function loadHostsCache(repoRoot) {
-  const cacheKey = repoRoot || process.cwd();
-  if (hostsCache && hostsCacheRoot === cacheKey) return;
-  hostsCache = readHosts(repoRoot);
-  hostsCacheRoot = cacheKey;
-}
-
-/**
- * hosts.json에서 호스트 OS를 조회한다.
- * @param {string} hostAlias — hosts.json의 키 (e.g. "ultra4")
- * @param {string} [repoRoot] — 프로젝트 루트 경로
- * @returns {"windows"|"posix"} 호스트 OS 유형
- */
-export function detectHostOs(hostAlias, repoRoot) {
-  loadHostsCache(repoRoot);
-
-  const hostCfg = resolveHost(hostAlias, repoRoot)?.host;
-  if (hostCfg?.os === "windows") return "windows";
-  if (hostCfg?.os) return "posix";
-
-  // IP 주소나 unknown alias → posix 기본값
-  return "posix";
-}
-
-/**
- * OS에 맞는 셸 쿼팅을 적용한다.
- * - posix: 싱글쿼트 래핑 + 내부 싱글쿼트 이스케이프
- * - windows: PowerShell 싱글쿼트 래핑 + 내부 싱글쿼트 더블링
- * @param {string} value
- * @param {"windows"|"posix"} os
- * @returns {string}
- */
-export function shellQuoteForHost(value, os) {
-  const s = String(value);
-  if (os === "windows") {
-    // PowerShell: 싱글쿼트 내부에서 '' 로 이스케이프
-    return `'${s.replace(/'/g, "''")}'`;
-  }
-  // POSIX: 싱글쿼트 내부에서 '\'' 로 이스케이프
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-
-/**
- * OS에 맞는 stderr 억제 구문을 반환한다.
- * @param {"windows"|"posix"} os
- * @returns {string} "2>$null" 또는 "2>/dev/null"
- */
-export function suppressStderr(os) {
-  return os === "windows" ? "2>$null" : "2>/dev/null";
-}
-
-/**
- * OS에 맞는 명령 연결자를 반환한다.
- * @param {"windows"|"posix"} os
- * @returns {string} "; " (PowerShell) 또는 " && " (bash)
- */
-export function commandJoin(os) {
-  return os === "windows" ? "; " : " && ";
-}
-
-/**
- * OS에 맞는 null 디바이스 경로를 반환한다.
- * @param {"windows"|"posix"} os
- * @returns {string}
- */
-export function nullDevice(os) {
-  return os === "windows" ? "$null" : "/dev/null";
-}
-
-/**
- * SSH execFileSync 인자 배열을 안전하게 구성한다.
- * psmux 명령처럼 원격 셸에서 실행할 명령을 배열로 받아
- * 적절한 쿼팅을 적용한 SSH 인자 배열을 반환한다.
- *
- * @param {string} host — SSH 호스트 (user@ip 또는 alias)
- * @param {string[]} remoteCmd — 원격에서 실행할 명령 + 인자
- * @param {object} [opts]
- * @param {number} [opts.connectTimeout=5] — SSH 연결 타임아웃(초)
- * @param {boolean} [opts.keepalive=true] — ServerAliveInterval/CountMax 활성화
- * @param {"windows"|"posix"} [opts.os] — 호스트 OS (미지정 시 자동 감지)
- * @param {string} [opts.repoRoot] — hosts.json 탐색 경로
- * @returns {string[]} execFileSync('ssh', returnValue) 형태로 사용
- */
-export function buildSshArgs(host, remoteCmd, opts = {}) {
-  const connectTimeout = opts.connectTimeout ?? 5;
-  const keepalive = opts.keepalive !== false;
-  const hostAlias = host.includes("@") ? host.split("@").pop() : host;
-  const os = opts.os ?? detectHostOs(hostAlias, opts.repoRoot);
-
-  // 명령어(첫 요소)는 쿼팅하지 않고, 인자만 쿼팅
-  const [cmd, ...args] = remoteCmd;
-  const quotedArgs = args.map((a) => shellQuoteForHost(a, os));
-  const remoteCmdStr = [cmd, ...quotedArgs].join(" ");
-
-  const sshArgs = [
-    "-o",
-    `ConnectTimeout=${connectTimeout}`,
-    "-o",
-    "BatchMode=yes",
-  ];
-
-  if (keepalive) {
-    sshArgs.push("-o", "ServerAliveInterval=30", "-o", "ServerAliveCountMax=3");
-  }
-
-  sshArgs.push(host, remoteCmdStr);
-  return sshArgs;
-}
-
-/**
- * 검증: 문자열에 호스트 OS와 맞지 않는 셸 문법이 포함되었는지 검사한다.
- * SSH 명령 생성 시 안전 게이트로 사용.
- *
- * @param {string} command — 원격 실행할 명령 문자열
- * @param {"windows"|"posix"} os — 대상 호스트 OS
- * @returns {{ safe: boolean, violations: string[] }}
- */
-export function validateCommandForOs(command, os) {
-  const violations = [];
-
-  if (os === "windows") {
-    // PowerShell에서 해석 불가능한 bash 문법 검출
-    if (/2>\/dev\/null/.test(command)) {
-      violations.push("2>/dev/null → PowerShell에서는 2>$null 사용");
-    }
-    if (/\$\(/.test(command) && !/\$\(/.test(command) === false) {
-      // $() bash substitution vs PowerShell $() — 문맥 의존
-      // PowerShell도 $()를 사용하므로 여기선 경고만
-    }
-    if (/\s&&\s/.test(command)) {
-      violations.push("&& → PowerShell에서는 ; 또는 -and 사용");
-    }
-    if (/\s\|\|\s/.test(command)) {
-      violations.push("|| → PowerShell에서는 ; 또는 -or 사용");
-    }
-    if (/>\s*\/dev\/null/.test(command)) {
-      violations.push(">/dev/null → PowerShell에서는 >$null 사용");
-    }
-  }
-
-  return { safe: violations.length === 0, violations };
-}
-
-/**
- * hosts.json에서 호스트 전체 설정을 조회한다.
- * @param {string} hostAlias — hosts.json의 키 (e.g. "ultra4")
- * @param {string} [repoRoot]
- * @returns {object|null}
- */
-export function getHostConfig(hostAlias, repoRoot) {
-  loadHostsCache(repoRoot);
-  return readHost(hostAlias, repoRoot);
-}
-
-/**
- * 별칭(alias)으로 호스트 키를 찾는다.
- * @param {string} alias — 호스트 키 또는 aliases 배열 내 값
- * @param {string} [repoRoot]
- * @returns {string|null} 호스트 키 (e.g. "ultra4") 또는 null
- */
-export function resolveHostAlias(alias, repoRoot) {
-  loadHostsCache(repoRoot);
-
-  return resolveHost(alias, repoRoot)?.name ?? null;
-}
-
-/**
- * 특정 capability를 보유한 호스트 목록을 반환한다.
- * 명시적 선택 UI에서 바로 리소스 정보를 보여줄 수 있도록 specs를 평탄화한다.
- * @param {string} capability — e.g. "codex", "claude", "gpu"
- * @param {string} [repoRoot]
- * @returns {Array<{ name: string, config: object, specs: { cores?: number, ram_gb?: number } }>}
- */
-export function selectHostForCapability(capability, repoRoot) {
-  loadHostsCache(repoRoot);
-
-  const matches = [];
-  for (const [name, cfg] of Object.entries(hostsCache.hosts || {})) {
-    if (cfg.capabilities?.includes(capability)) {
-      matches.push({
-        name,
-        config: cfg,
-        specs: {
-          cores: cfg.specs?.cores,
-          ram_gb: cfg.specs?.ram_gb,
-        },
-      });
-    }
-  }
-  return matches;
-}
-
-/**
- * 특정 capability를 가진 호스트를 리소스 기준으로 정렬해 반환한다.
- * 자동 선택은 하지 않고, 명시적 선택 목록 정렬에만 사용한다.
- * @param {string} capability — e.g. "codex", "claude", "gpu"
- * @param {"cores"|"ram_gb"} sortBy
- * @param {string} [repoRoot]
- * @returns {Array<{ name: string, config: object, specs: { cores?: number, ram_gb?: number } }>}
- */
-export function selectHostByResources(capability, sortBy, repoRoot) {
-  if (sortBy !== "cores" && sortBy !== "ram_gb") {
-    throw new TypeError('sortBy must be "cores" or "ram_gb"');
-  }
-
-  return selectHostForCapability(capability, repoRoot).sort((a, b) => {
-    const aValue = a.specs?.[sortBy] ?? -Infinity;
-    const bValue = b.specs?.[sortBy] ?? -Infinity;
-    return bValue - aValue;
-  });
-}
-
-/** hosts.json 캐시 초기화 (테스트용) */
-export function resetHostsCache() {
-  hostsCache = null;
-  hostsCacheRoot = null;
-}