triflux 8.11.2 → 8.12.2

package/scripts/lib/remote-spawn-transfer.mjs

@@ -0,0 +1,196 @@
+import { existsSync, readFileSync, statSync } from "fs";
+import { basename, dirname, isAbsolute, resolve } from "path";
+
+const URL_LIKE_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//u;
+const WINDOWS_ABS_RE = /^[a-zA-Z]:[\\/]/u;
+
+function normalizeMarkdownTarget(raw) {
+  const trimmed = String(raw || "").trim();
+  const match = /^<?([^>\s]+)>?(?:\s+["'][^"']*["'])?$/u.exec(trimmed);
+  return match ? match[1] : trimmed;
+}
+
+function sanitizeToken(raw) {
+  let token = String(raw || "").trim();
+  if (!token) return "";
+  token = token.replace(/^[<(]+/u, "").replace(/[)>.,;:!?]+$/u, "").trim();
+  return token;
+}
+
+function isLikelyPathToken(token) {
+  if (!token || URL_LIKE_RE.test(token)) return false;
+  if (token.startsWith("app://") || token.startsWith("plugin://") || token.startsWith("mention://")) return false;
+  if (token === "~") return false;
+
+  const hasPathSeparator = token.includes("/") || token.includes("\\");
+  const hasDotPrefix = token.startsWith("./") || token.startsWith("../") || token.startsWith(".");
+  const isHomeRelative = token.startsWith("~/") || token.startsWith("~\\");
+  const isWindowsAbs = WINDOWS_ABS_RE.test(token);
+  const hasFileLikeSuffix = /\.[a-zA-Z0-9]{1,16}$/u.test(token);
+
+  return hasPathSeparator || hasDotPrefix || isHomeRelative || isWindowsAbs || hasFileLikeSuffix;
+}
+
+export function extractExplicitFileTokens(text) {
+  const content = String(text || "");
+  const candidates = [];
+
+  for (const match of content.matchAll(/\[[^\]]+\]\(([^)\n]+)\)/gu)) {
+    candidates.push(normalizeMarkdownTarget(match[1]));
+  }
+  for (const match of content.matchAll(/`([^`\n]+)`/gu)) {
+    candidates.push(match[1]);
+  }
+  for (const match of content.matchAll(/"([^"\n]+)"/gu)) {
+    candidates.push(match[1]);
+  }
+  for (const match of content.matchAll(/'([^'\n]+)'/gu)) {
+    candidates.push(match[1]);
+  }
+
+  const unique = new Set();
+  for (const raw of candidates) {
+    const token = sanitizeToken(raw);
+    if (!isLikelyPathToken(token)) continue;
+    unique.add(token);
+  }
+
+  return Array.from(unique);
+}
+
+function validateTransferFile(filePath, maxBytes) {
+  if (!existsSync(filePath)) {
+    throw new Error(`referenced file not found: ${filePath}`);
+  }
+  const stats = statSync(filePath);
+  if (!stats.isFile()) {
+    throw new Error(`referenced path is not a file: ${filePath}`);
+  }
+  if (stats.size > maxBytes) {
+    throw new Error(`referenced file too large: ${stats.size} bytes (max ${maxBytes}) for ${filePath}`);
+  }
+  return stats.size;
+}
+
+function resolveReferencePath(token, handoffAbsPath, cwd) {
+  if (WINDOWS_ABS_RE.test(token) || isAbsolute(token)) {
+    return resolve(token);
+  }
+
+  if (token.startsWith("~/") || token.startsWith("~\\")) {
+    if (!process.env.HOME && !process.env.USERPROFILE) {
+      return null;
+    }
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    return resolve(homeDir, token.slice(2));
+  }
+
+  const handoffDir = dirname(handoffAbsPath);
+  const primary = resolve(handoffDir, token);
+  if (existsSync(primary)) {
+    return primary;
+  }
+
+  const fallback = resolve(cwd, token);
+  return existsSync(fallback) ? fallback : primary;
+}
+
+function toRemotePath(stageRoot, relativePath) {
+  const root = String(stageRoot).replace(/\\/gu, "/").replace(/\/+$/u, "");
+  const rel = String(relativePath).replace(/\\/gu, "/").replace(/^\/+/, "");
+  return `${root}/${rel}`;
+}
+
+export function buildRemoteTransferPlan(options = {}) {
+  const {
+    cwd = process.cwd(),
+    handoffPath = null,
+    maxBytes,
+    remoteStageRoot,
+    userPrompt = null,
+    maxReferenceFiles = 32,
+  } = options;
+
+  if (!handoffPath) {
+    return {
+      prompt: userPrompt || "",
+      replacements: [],
+      stagedHandoffPath: null,
+      transfers: [],
+    };
+  }
+
+  if (!remoteStageRoot) {
+    throw new Error("remoteStageRoot is required when handoffPath is provided");
+  }
+
+  if (!Number.isFinite(maxBytes) || maxBytes <= 0) {
+    throw new Error("maxBytes must be a positive number");
+  }
+
+  const absoluteHandoffPath = resolve(cwd, handoffPath);
+  validateTransferFile(absoluteHandoffPath, maxBytes);
+  const handoffContent = readFileSync(absoluteHandoffPath, "utf8").trim();
+
+  const stagedHandoffPath = toRemotePath(remoteStageRoot, `handoff/${basename(absoluteHandoffPath)}`);
+  const transfers = [{
+    localPath: absoluteHandoffPath,
+    remotePath: stagedHandoffPath,
+    type: "handoff",
+  }];
+
+  const tokens = extractExplicitFileTokens(handoffContent);
+  if (tokens.length > maxReferenceFiles) {
+    throw new Error(`too many referenced files: ${tokens.length} (max ${maxReferenceFiles})`);
+  }
+
+  const stagedByLocalPath = new Map();
+  const replacements = [];
+  let fileIndex = 0;
+
+  for (const token of tokens) {
+    const resolvedPath = resolveReferencePath(token, absoluteHandoffPath, cwd);
+    validateTransferFile(resolvedPath, maxBytes);
+
+    if (!stagedByLocalPath.has(resolvedPath)) {
+      fileIndex += 1;
+      const stagedPath = toRemotePath(
+        remoteStageRoot,
+        `refs/${String(fileIndex).padStart(2, "0")}-${basename(resolvedPath)}`,
+      );
+      stagedByLocalPath.set(resolvedPath, stagedPath);
+      transfers.push({
+        localPath: resolvedPath,
+        remotePath: stagedPath,
+        type: "reference",
+      });
+    }
+
+    replacements.push({ token, stagedPath: stagedByLocalPath.get(resolvedPath) });
+  }
+
+  const replacementEntries = Array.from(
+    replacements
+      .reduce((map, entry) => map.set(entry.token, entry.stagedPath), new Map())
+      .entries(),
+  ).sort((a, b) => b[0].length - a[0].length);
+
+  let rewrittenHandoff = handoffContent;
+  for (const [token, stagedPath] of replacementEntries) {
+    rewrittenHandoff = rewrittenHandoff.split(token).join(stagedPath);
+  }
+
+  const prefix = `Staged handoff file: ${stagedHandoffPath}`;
+  let prompt = rewrittenHandoff ? `${prefix}\n\n${rewrittenHandoff}` : prefix;
+
+  if (userPrompt) {
+    prompt = `${prompt}\n\n---\n\n${userPrompt}`;
+  }
+
+  return {
+    prompt,
+    replacements: replacementEntries.map(([token, stagedPath]) => ({ stagedPath, token })),
+    stagedHandoffPath,
+    transfers,
+  };
+}

package/scripts/mcp-check.mjs

@@ -1,127 +1,237 @@
-#!/usr/bin/env node
-// MCP inventory cache for dynamic MCP filtering.
-
-import { execSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { normalizeServerMetadata } from './lib/mcp-server-catalog.mjs';
-
-const CACHE_DIR = join(homedir(), '.claude', 'cache');
-const CACHE_FILE = join(CACHE_DIR, 'mcp-inventory.json');
-
-function countConfiguredTools(config = {}, fallbackToolCount = 0) {
-  const directKeys = ['tools', 'toolNames', 'allowedTools', 'includeTools'];
-  for (const key of directKeys) {
-    if (Array.isArray(config[key])) return config[key].length;
-  }
-
-  if (Array.isArray(config.excludeTools)) {
-    return Math.max(0, fallbackToolCount - config.excludeTools.length);
-  }
-
-  return fallbackToolCount;
-}
-
-export function createServerRecord(name, status, config = {}) {
-  const normalizedName = typeof name === 'string' ? name.trim() : '';
-  const fallback = normalizeServerMetadata(normalizedName, {});
-  const toolCount = countConfiguredTools(config, fallback.tool_count);
-  const domainTags = Array.isArray(config.domain_tags)
-    ? config.domain_tags
-    : Array.isArray(config.domainTags)
-      ? config.domainTags
-      : [];
-
-  const metadata = normalizeServerMetadata(normalizedName, {
-    ...config,
-    tool_count: toolCount,
-    domain_tags: domainTags,
-  });
-
-  return {
-    name: normalizedName,
-    status,
-    tool_count: metadata.tool_count,
-    domain_tags: metadata.domain_tags,
-  };
-}
-
-export function getCodexMcp() {
-  try {
-    const output = execSync('codex mcp list', {
-      encoding: 'utf8',
-      timeout: 15000,
-      stdio: ['pipe', 'pipe', 'ignore'],
-      windowsHide: true,
-    });
-    const lines = output.trim().split(/\r?\n/).filter((line) => line.trim());
-    if (lines.length < 2) return [];
-
-    const servers = [];
-    for (let i = 1; i < lines.length; i += 1) {
-      const cols = lines[i].split(/\s{2,}/);
-      if (cols.length < 2) continue;
-
-      const name = cols[0].trim();
-      const statusMatch = lines[i].match(/\b(enabled|disabled)\b/i);
-      const status = statusMatch ? statusMatch[1].toLowerCase() : 'unknown';
-      if (!name || name.startsWith('-')) continue;
-      servers.push(createServerRecord(name, status));
-    }
-    return servers;
-  } catch {
-    return null;
-  }
-}
-
-export function getGeminiMcp() {
-  try {
-    const settingsPath = join(homedir(), '.gemini', 'settings.json');
-    if (!existsSync(settingsPath)) return null;
-
-    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
-    const mcpServers = settings.mcpServers || {};
-    return Object.entries(mcpServers).map(([name, config]) => createServerRecord(name, 'configured', config || {}));
-  } catch {
-    return null;
-  }
-}
-
-export function buildInventory() {
-  const inventory = {
-    timestamp: new Date().toISOString(),
-    codex: { available: false, servers: [] },
-    gemini: { available: false, servers: [] },
-  };
-
-  const codexServers = getCodexMcp();
-  if (codexServers !== null) {
-    inventory.codex.available = true;
-    inventory.codex.servers = codexServers;
-  }
-
-  const geminiServers = getGeminiMcp();
-  if (geminiServers !== null) {
-    inventory.gemini.available = true;
-    inventory.gemini.servers = geminiServers;
-  }
-
-  return inventory;
-}
-
-export function writeInventoryCache(inventory = buildInventory()) {
-  if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
-  writeFileSync(CACHE_FILE, JSON.stringify(inventory, null, 2));
-  return inventory;
-}
-
-export function main() {
-  writeInventoryCache();
-}
-
-if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
-  main();
-}
+#!/usr/bin/env node
+// MCP inventory cache for dynamic MCP filtering.
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { MCP_SERVER_TOOL_CATALOG, normalizeServerMetadata } from './lib/mcp-server-catalog.mjs';
+
+const CACHE_DIR = join(homedir(), '.claude', 'cache');
+const CACHE_FILE = join(CACHE_DIR, 'mcp-inventory.json');
+
+function countConfiguredTools(config = {}, fallbackToolCount = 0) {
+  const directKeys = ['tools', 'toolNames', 'allowedTools', 'includeTools'];
+  for (const key of directKeys) {
+    if (Array.isArray(config[key])) return config[key].length;
+  }
+
+  if (Array.isArray(config.excludeTools)) {
+    return Math.max(0, fallbackToolCount - config.excludeTools.length);
+  }
+
+  return fallbackToolCount;
+}
+
+export function createServerRecord(name, status, config = {}) {
+  const normalizedName = typeof name === 'string' ? name.trim() : '';
+  const fallback = normalizeServerMetadata(normalizedName, {});
+  const toolCount = countConfiguredTools(config, fallback.tool_count);
+  const domainTags = Array.isArray(config.domain_tags)
+    ? config.domain_tags
+    : Array.isArray(config.domainTags)
+      ? config.domainTags
+      : [];
+
+  const metadata = normalizeServerMetadata(normalizedName, {
+    ...config,
+    tool_count: toolCount,
+    domain_tags: domainTags,
+  });
+
+  return {
+    name: normalizedName,
+    status,
+    tool_count: metadata.tool_count,
+    domain_tags: metadata.domain_tags,
+  };
+}
+
+export function getCodexMcp() {
+  try {
+    const output = execSync('codex mcp list', {
+      encoding: 'utf8',
+      timeout: 15000,
+      stdio: ['pipe', 'pipe', 'ignore'],
+      windowsHide: true,
+    });
+    const lines = output.trim().split(/\r?\n/).filter((line) => line.trim());
+    if (lines.length < 2) return [];
+
+    const servers = [];
+    for (let i = 1; i < lines.length; i += 1) {
+      const cols = lines[i].split(/\s{2,}/);
+      if (cols.length < 2) continue;
+
+      const name = cols[0].trim();
+      const statusMatch = lines[i].match(/\b(enabled|disabled)\b/i);
+      const status = statusMatch ? statusMatch[1].toLowerCase() : 'unknown';
+      if (!name || name.startsWith('-')) continue;
+      servers.push(createServerRecord(name, status));
+    }
+    return servers;
+  } catch {
+    return null;
+  }
+}
+
+export function getGeminiMcp() {
+  try {
+    const settingsPath = join(homedir(), '.gemini', 'settings.json');
+    if (!existsSync(settingsPath)) return null;
+
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const mcpServers = settings.mcpServers || {};
+    return Object.entries(mcpServers).map(([name, config]) => createServerRecord(name, 'configured', config || {}));
+  } catch {
+    return null;
+  }
+}
+
+// ── Claude MCP 서버 발견 ──
+
+const CLAUDE_DIR = join(homedir(), '.claude');
+
+// Anthropic 클라우드 호스팅 MCP 서버 — Claude Code 런타임에서 항상 가용.
+// mcp-server-catalog.mjs의 MCP_SERVER_TOOL_CATALOG에 정의된 서버 중
+// 로컬 설치가 불필요한 클라우드 제공 서버.
+const WELL_KNOWN_CLOUD_SERVERS = Object.freeze([
+  'brave-search',
+  'exa',
+  'context7',
+]);
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function extractMcpServerNames(mcpJsonPath) {
+  const data = readJsonSafe(mcpJsonPath);
+  if (!data?.mcpServers || typeof data.mcpServers !== 'object') return [];
+  return Object.entries(data.mcpServers)
+    .filter(([name]) => typeof name === 'string' && name.trim())
+    .map(([name, config]) => ({ name: name.trim(), config: config || {} }));
+}
+
+function walkUpForMcpJson(startDir, maxDepth = 5) {
+  const found = [];
+  let dir = resolve(startDir);
+  for (let i = 0; i < maxDepth; i += 1) {
+    const candidate = join(dir, '.mcp.json');
+    if (existsSync(candidate)) found.push(candidate);
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return found;
+}
+
+function scanPluginsMcpJson() {
+  const pluginsDir = join(CLAUDE_DIR, 'plugins');
+  if (!existsSync(pluginsDir)) return [];
+  const found = [];
+  const walk = (dir, depth = 0) => {
+    if (depth > 4) return;
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === 'node_modules' || entry.name === '.git') continue;
+        const full = join(dir, entry.name);
+        if (entry.isFile() && entry.name === '.mcp.json') {
+          found.push(full);
+        } else if (entry.isDirectory()) {
+          walk(full, depth + 1);
+        }
+      }
+    } catch { /* permission errors */ }
+  };
+  walk(pluginsDir);
+  return found;
+}
+
+export function getClaudeMcp(cwd = process.cwd()) {
+  const serverMap = new Map();
+
+  // 1) .mcp.json 파일 트리 스캔 (CWD → root)
+  for (const mcpJson of walkUpForMcpJson(cwd)) {
+    for (const { name, config } of extractMcpServerNames(mcpJson)) {
+      if (!serverMap.has(name)) {
+        serverMap.set(name, createServerRecord(name, 'configured', config));
+      }
+    }
+  }
+
+  // 2) ~/.claude/plugins/ 스캔
+  for (const mcpJson of scanPluginsMcpJson()) {
+    for (const { name, config } of extractMcpServerNames(mcpJson)) {
+      if (!serverMap.has(name)) {
+        serverMap.set(name, createServerRecord(name, 'configured', config));
+      }
+    }
+  }
+
+  // 3) ~/.claude/settings.json + settings.local.json의 mcpServers
+  for (const settingsFile of ['settings.json', 'settings.local.json']) {
+    const data = readJsonSafe(join(CLAUDE_DIR, settingsFile));
+    if (!data?.mcpServers) continue;
+    for (const [name, config] of Object.entries(data.mcpServers)) {
+      if (typeof name !== 'string' || !name.trim()) continue;
+      if (!serverMap.has(name.trim())) {
+        serverMap.set(name.trim(), createServerRecord(name.trim(), 'configured', config || {}));
+      }
+    }
+  }
+
+  // 4) Well-known Anthropic 클라우드 MCP 서버 (카탈로그에 정의된 것만)
+  for (const name of WELL_KNOWN_CLOUD_SERVERS) {
+    if (serverMap.has(name)) continue;
+    if (!MCP_SERVER_TOOL_CATALOG[name]) continue;
+    serverMap.set(name, createServerRecord(name, 'available'));
+  }
+
+  return [...serverMap.values()];
+}
+
+export function buildInventory(cwd = process.cwd()) {
+  const inventory = {
+    timestamp: new Date().toISOString(),
+    codex: { available: false, servers: [] },
+    gemini: { available: false, servers: [] },
+    claude: { available: true, servers: [] },
+  };
+
+  const codexServers = getCodexMcp();
+  if (codexServers !== null) {
+    inventory.codex.available = true;
+    inventory.codex.servers = codexServers;
+  }
+
+  const geminiServers = getGeminiMcp();
+  if (geminiServers !== null) {
+    inventory.gemini.available = true;
+    inventory.gemini.servers = geminiServers;
+  }
+
+  inventory.claude.servers = getClaudeMcp(cwd);
+
+  return inventory;
+}
+
+export function writeInventoryCache(inventory = buildInventory()) {
+  if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+  writeFileSync(CACHE_FILE, JSON.stringify(inventory, null, 2));
+  return inventory;
+}
+
+export function main() {
+  writeInventoryCache();
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  main();
+}

package/scripts/mcp-gateway-ensure.mjs

@@ -4,7 +4,7 @@
 
 import { existsSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { spawn } from 'node:child_process';
+import { execSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 
@@ -35,18 +35,16 @@ function hasManifest() {
   return existsSync(PID_FILE);
 }
 
-/** mcp-gateway-start.mjs를 detached로 기동 */
+/** mcp-gateway-start.mjs를 독립 프로세스로 기동 */
 function startGateway() {
   const scriptPath = join(PLUGIN_ROOT, 'scripts', 'mcp-gateway-start.mjs');
   if (!existsSync(scriptPath)) return false;
 
   try {
-    // hub-ensure.mjs 패턴: cmd.exe /c start /b → hook timeout에서 생존
-    const child = spawn('cmd.exe', ['/c', 'start', '/b', '', process.execPath, scriptPath], {
-      stdio: 'ignore',
-      windowsHide: true,
-    });
-    child.unref();
+    // PowerShell Start-Process: Windows Job Object에서 벗어나 부모 종료 후 생존
+    execSync(
+      `powershell -NoProfile -Command "Start-Process -WindowStyle Hidden -FilePath '${process.execPath}' -ArgumentList '${scriptPath.replaceAll("'", "''")}'"`
+    , { stdio: 'ignore', timeout: 10000 });
     return true;
   } catch {
     return false;