@triflux/core 10.1.0 → 10.26.0

package/hub/lib/hosts-compat.mjs

@@ -0,0 +1,319 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+const HOSTS_LOCATIONS = [
+  ["references", "hosts.json"],
+  ["skills", "tfx-remote-spawn", "references", "hosts.json"],
+  ["packages", "triflux", "references", "hosts.json"],
+];
+
+let migrated = false;
+
+function readJsonFile(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+export function userStateHostsPath() {
+  if (process.env.TFX_HOSTS_USER_STATE_DISABLE === "1") return null;
+  if (process.env.TFX_HOSTS_USER_STATE) return process.env.TFX_HOSTS_USER_STATE;
+  if (process.platform === "win32") {
+    return join(
+      process.env.APPDATA || join(homedir(), "AppData", "Roaming"),
+      "triflux",
+      "hosts.json",
+    );
+  }
+  return join(homedir(), ".config", "triflux", "hosts.json");
+}
+
+function candidatePaths(repoRoot) {
+  const root = repoRoot || process.cwd();
+  const repoRootCandidates = HOSTS_LOCATIONS.map((segments) =>
+    join(root, ...segments),
+  );
+  const userPath = userStateHostsPath();
+  return userPath ? [userPath, ...repoRootCandidates] : repoRootCandidates;
+}
+
+export function migrateLegacyHosts(repoRoot) {
+  const to = userStateHostsPath();
+  let from = null;
+  if (!to) {
+    return {
+      migrated: false,
+      from: null,
+      to: null,
+      reason: "user-state-disabled",
+    };
+  }
+  try {
+    if (existsSync(to)) {
+      return { migrated: false, from: null, to, reason: "already-exists" };
+    }
+
+    const root = repoRoot || process.cwd();
+    from =
+      HOSTS_LOCATIONS.map((segments) => join(root, ...segments)).find((path) =>
+        existsSync(path),
+      ) || null;
+    if (!from) {
+      return { migrated: false, from: null, to, reason: "not-found" };
+    }
+
+    mkdirSync(dirname(to), { recursive: true });
+    copyFileSync(from, to);
+    return { migrated: true, from, to };
+  } catch (error) {
+    return {
+      migrated: false,
+      from,
+      to,
+      reason: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function canonicalOs(rawOs) {
+  const value = String(rawOs || "")
+    .trim()
+    .toLowerCase();
+  if (!value) return "linux";
+  if (
+    value === "win32" ||
+    value === "windows" ||
+    value.startsWith("windows-")
+  ) {
+    return "windows";
+  }
+  if (value === "macos" || value === "darwin" || value.includes("darwin")) {
+    return "darwin";
+  }
+  return "linux";
+}
+
+function normalizeCapabilitiesArray(rawArray, rawMap) {
+  const fromArray = Array.isArray(rawArray)
+    ? rawArray.map((item) => String(item).trim()).filter(Boolean)
+    : [];
+  const fromMap =
+    rawMap && typeof rawMap === "object"
+      ? Object.entries(rawMap)
+          .filter(([, enabled]) => Boolean(enabled))
+          .map(([name]) => String(name).trim().replace(/_/g, "-"))
+      : [];
+  return [...new Set([...fromArray, ...fromMap])];
+}
+
+function normalizeCapabilitiesMap(rawMap, rawArray) {
+  const normalized = {};
+  if (rawMap && typeof rawMap === "object") {
+    for (const [key, enabled] of Object.entries(rawMap)) {
+      normalized[String(key).trim()] = Boolean(enabled);
+    }
+  }
+  if (Array.isArray(rawArray)) {
+    for (const item of rawArray) {
+      const key = String(item).trim().replace(/-/g, "_");
+      if (key) normalized[key] = true;
+    }
+  }
+  return normalized;
+}
+
+function normalizeLastProbe(rawProbe) {
+  if (!rawProbe || typeof rawProbe !== "object") {
+    return null;
+  }
+  const probe = {};
+  if (typeof rawProbe.ok === "boolean") probe.ok = rawProbe.ok;
+  if (rawProbe.ts) probe.ts = String(rawProbe.ts);
+  if (Number.isFinite(rawProbe.latency_ms))
+    probe.latency_ms = rawProbe.latency_ms;
+  return Object.keys(probe).length > 0 ? probe : null;
+}
+
+function normalizeResources(rawHost) {
+  const rawResources =
+    rawHost.resources && typeof rawHost.resources === "object"
+      ? rawHost.resources
+      : {};
+  const rawSpecs =
+    rawHost.specs && typeof rawHost.specs === "object" ? rawHost.specs : {};
+  return { ...rawResources, ...rawSpecs };
+}
+
+export function normalizeHost(rawHost = {}, name = "") {
+  const sshUser = rawHost.ssh_user || rawHost.ssh?.user || rawHost.user || null;
+  const sshHost = rawHost.ssh?.host || rawHost.host || null;
+  const resources = normalizeResources(rawHost);
+  const tailscale = {
+    ip: rawHost.tailscale?.ip || null,
+    dns: rawHost.tailscale?.dns || null,
+    ssh_mode: rawHost.tailscale?.ssh_mode || null,
+  };
+  const capabilities = normalizeCapabilitiesArray(
+    rawHost.capabilities,
+    rawHost.capabilities_v2,
+  );
+  const capabilities_v2 = normalizeCapabilitiesMap(
+    rawHost.capabilities_v2,
+    rawHost.capabilities,
+  );
+
+  return {
+    name,
+    description: rawHost.description || name,
+    aliases: Array.isArray(rawHost.aliases)
+      ? [
+          ...new Set(
+            rawHost.aliases
+              .map((alias) => String(alias).trim())
+              .filter(Boolean),
+          ),
+        ]
+      : [],
+    default_dir: rawHost.default_dir || "~",
+    os: canonicalOs(rawHost.os),
+    ssh_user: sshUser,
+    ssh: {
+      ...(rawHost.ssh && typeof rawHost.ssh === "object" ? rawHost.ssh : {}),
+      user: sshUser,
+      host: sshHost,
+    },
+    tailscale,
+    capabilities,
+    capabilities_v2,
+    last_probe: normalizeLastProbe(rawHost.last_probe),
+    resources,
+    specs: { ...resources },
+    raw: { ...rawHost },
+  };
+}
+
+export function readHosts(repoRoot) {
+  if (!migrated) {
+    migrateLegacyHosts(repoRoot);
+    migrated = true;
+  }
+
+  for (const path of candidatePaths(repoRoot)) {
+    if (!existsSync(path)) continue;
+    const parsed = readJsonFile(path);
+    const normalizedHosts = Object.fromEntries(
+      Object.entries(parsed.hosts || {}).map(([name, host]) => [
+        name,
+        normalizeHost(host, name),
+      ]),
+    );
+    return {
+      path,
+      raw: parsed,
+      hosts: normalizedHosts,
+      default_host:
+        parsed.default_host && normalizedHosts[parsed.default_host]
+          ? parsed.default_host
+          : null,
+      triggers: Array.isArray(parsed.triggers)
+        ? parsed.triggers.map((item) => String(item).trim()).filter(Boolean)
+        : [],
+    };
+  }
+
+  return {
+    path: null,
+    raw: { hosts: {} },
+    hosts: {},
+    default_host: null,
+    triggers: [],
+  };
+}
+
+export function resolveHost(nameOrAlias, repoRoot) {
+  if (!nameOrAlias) return null;
+  const registry = readHosts(repoRoot);
+  const needle = String(nameOrAlias).trim();
+  if (!needle) return null;
+
+  if (registry.hosts[needle]) {
+    return { name: needle, host: registry.hosts[needle], registry };
+  }
+
+  const lowered = needle.toLowerCase();
+  for (const [name, host] of Object.entries(registry.hosts)) {
+    const aliases = new Set([
+      ...host.aliases,
+      host.tailscale.ip,
+      host.tailscale.dns,
+      host.ssh.host,
+      host.ssh_user ? `${host.ssh_user}@${name}` : null,
+      host.ssh_user && host.tailscale.ip
+        ? `${host.ssh_user}@${host.tailscale.ip}`
+        : null,
+      host.ssh_user && host.tailscale.dns
+        ? `${host.ssh_user}@${host.tailscale.dns}`
+        : null,
+      host.ssh_user && host.ssh.host
+        ? `${host.ssh_user}@${host.ssh.host}`
+        : null,
+    ]);
+    for (const alias of aliases) {
+      if (alias && String(alias).toLowerCase() === lowered) {
+        return { name, host, registry };
+      }
+    }
+  }
+
+  return null;
+}
+
+export function readHost(nameOrAlias, repoRoot) {
+  return resolveHost(nameOrAlias, repoRoot)?.host ?? null;
+}
+
+export function selfTestFixtures() {
+  const v1 = normalizeHost(
+    {
+      description: "legacy",
+      aliases: ["desk"],
+      default_dir: "~/Desktop/Projects",
+      os: "win32",
+      ssh_user: "SSAFY",
+      tailscale: { ip: "100.64.0.1", dns: "desk.ts.net" },
+      capabilities: ["codex", "claude"],
+    },
+    "ultra4",
+  );
+  const v2 = normalizeHost(
+    {
+      description: "modern",
+      aliases: ["mac"],
+      default_dir: "~/projects",
+      os: "darwin kernel",
+      ssh: { user: "tellang" },
+      tailscale: {
+        ip: "100.64.0.2",
+        dns: "mac.ts.net",
+        ssh_mode: "ssh-over-vpn",
+      },
+      capabilities_v2: { codex: true, claude: true, high_memory: true },
+      last_probe: { ok: true, ts: "2026-04-18T12:34:56Z", latency_ms: 143 },
+    },
+    "m2",
+  );
+  return {
+    v1,
+    v2,
+    checks: {
+      v1_os: v1.os === "windows",
+      v1_ssh_user: v1.ssh.user === "SSAFY" && v1.ssh_user === "SSAFY",
+      v2_os: v2.os === "darwin",
+      v2_caps: v2.capabilities.includes("high-memory"),
+      v2_probe: v2.last_probe?.ok === true && v2.last_probe?.latency_ms === 143,
+    },
+  };
+}
+
+if (process.argv.includes("--self-test")) {
+  process.stdout.write(`${JSON.stringify(selfTestFixtures(), null, 2)}\n`);
+}

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

@@ -0,0 +1,239 @@
+// 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;
+}