triflux 10.0.0 → 10.0.2

package/scripts/mcp-gateway-config.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+// mcp-gateway-config.mjs — Claude Code MCP stdio↔SSE 전환
+// Usage: node mcp-gateway-config.mjs --enable   # stdio → SSE
+//        node mcp-gateway-config.mjs --disable  # SSE → stdio (복원)
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { isServerEnabled } from './lib/mcp-manifest.mjs';
+
+const BACKUP_FILE = join(homedir(), '.claude', 'cache', 'mcp-pre-gateway.json');
+
+export const GATEWAY_SERVERS = [
+  { name: 'context7',     port: 8100, stdioCmd: 'cmd /c npx -y @upstash/context7-mcp@latest' },
+  { name: 'brave-search', port: 8101, stdioCmd: 'cmd /c npx -y @brave/brave-search-mcp-server' },
+  { name: 'exa',          port: 8102, stdioCmd: 'cmd /c npx -y exa-mcp-server' },
+  { name: 'tavily',       port: 8103, stdioCmd: 'cmd /c npx -y tavily-mcp@latest' },
+  { name: 'jira',         port: 8104, stdioCmd: 'cmd /c npx -y mcp-jira-cloud@latest' },
+  { name: 'serena',       port: 8105, stdioCmd: 'uvx --from git+https://github.com/oraios/serena serena start-mcp-server' },
+  { name: 'notion',       port: 8106, stdioCmd: 'cmd /c npx -y @notionhq/notion-mcp-server' },
+  { name: 'notion-guest', port: 8107, stdioCmd: 'cmd /c npx -y @notionhq/notion-mcp-server' },
+];
+
+const SKIP_SERVERS = new Set([
+  'playwright',
+  'claude.ai Notion',
+  'plugin:oh-my-claudecode:t',
+]);
+
+// Git Bash에서 /c → C:/ 경로 변환 방지
+const EXEC_ENV = { ...process.env, MSYS_NO_PATHCONV: '1' };
+
+function run(cmd) {
+  try {
+    execSync(cmd, { stdio: 'pipe', encoding: 'utf8', timeout: 15000, env: EXEC_ENV });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removeMcp(name) {
+  run(`claude mcp remove "${name}" -s user`);
+  run(`claude mcp remove "${name}" -s local`);
+}
+
+// ── 스냅샷: enable 전 기존 MCP 설정 백업 ──
+
+function captureCurrentMcpState() {
+  const servers = {};
+  for (const { name } of GATEWAY_SERVERS) {
+    if (SKIP_SERVERS.has(name)) continue;
+    // claude mcp get으로 현재 등록 상태 확인
+    try {
+      const out = execSync(`claude mcp get "${name}" -s user`, {
+        stdio: 'pipe', encoding: 'utf8', timeout: 5000, env: EXEC_ENV,
+      }).trim();
+      servers[name] = { scope: 'user', raw: out };
+    } catch {
+      // user에 없으면 local 확인
+      try {
+        const out = execSync(`claude mcp get "${name}" -s local`, {
+          stdio: 'pipe', encoding: 'utf8', timeout: 5000, env: EXEC_ENV,
+        }).trim();
+        servers[name] = { scope: 'local', raw: out };
+      } catch {
+        servers[name] = null; // 기존에 없었음
+      }
+    }
+  }
+  return servers;
+}
+
+function saveBackup(servers) {
+  const dir = dirname(BACKUP_FILE);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const backup = { captured_at: new Date().toISOString(), servers };
+  writeFileSync(BACKUP_FILE, JSON.stringify(backup, null, 2));
+  console.log(`  [BACKUP] ${BACKUP_FILE}`);
+}
+
+function loadBackup() {
+  if (!existsSync(BACKUP_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(BACKUP_FILE, 'utf8'));
+  } catch { return null; }
+}
+
+// ── enable: 스냅샷 → remove → SSE add (실패 시 rollback) ──
+
+function enableSse() {
+  console.log('Switching MCP servers to SSE mode...\n');
+
+  // 1) 현재 상태 스냅샷
+  const snapshot = captureCurrentMcpState();
+  saveBackup(snapshot);
+
+  let ok = 0;
+  let fail = 0;
+
+  for (const { name, port } of GATEWAY_SERVERS) {
+    if (SKIP_SERVERS.has(name)) continue;
+    if (!isServerEnabled(name)) {
+      console.log(`  [SKIP] ${name} — manifest에서 비활성`);
+      continue;
+    }
+
+    removeMcp(name);
+    const url = `http://localhost:${port}/sse`;
+    const success = run(`claude mcp add --transport sse -s user "${name}" ${url}`);
+
+    if (success) {
+      console.log(`  [SSE] ${name} → ${url}`);
+      ok++;
+    } else {
+      // add 실패 → 원본 복원 시도
+      console.error(`  [FAIL] ${name} — rollback 시도`);
+      const orig = snapshot[name];
+      if (orig) {
+        // H1 fix: orig.raw를 shell-escape하여 injection 방지
+      const safeRaw = (orig.raw || '').replace(/[;`$(){}|&<>]/g, '');
+      const restored = safeRaw ? run(`claude mcp add "${name}" -s ${orig.scope} -- ${safeRaw}`) : false;
+        console.error(`  [ROLLBACK] ${name}: ${restored ? 'ok' : 'FAIL'}`);
+      }
+      fail++;
+    }
+  }
+
+  console.log(`\nDone: ${ok} switched, ${fail} failed`);
+}
+
+// ── disable: 백업에서 서버별 원복 ──
+
+function disableSse() {
+  console.log('Restoring MCP servers from backup...\n');
+  const backup = loadBackup();
+
+  // C1 fix: 백업 없으면 전체 삭제 방지
+  if (!backup) {
+    console.error('No backup found — cannot restore. Run --enable first to create a backup.');
+    process.exit(1);
+  }
+
+  let ok = 0;
+  let fail = 0;
+
+  for (const { name, stdioCmd } of GATEWAY_SERVERS) {
+    if (SKIP_SERVERS.has(name)) continue;
+
+    const orig = backup.servers?.[name];
+
+    if (orig === null || orig === undefined) {
+      // 기존에 없었던 서버 → triflux가 추가한 것 → remove만
+      removeMcp(name);
+      console.log(`  [REMOVE] ${name} — triflux가 추가한 서버, 원본 없음`);
+      ok++;
+      continue;
+    }
+
+    // H2 fix: 백업의 scope/raw를 사용하여 원본 복원, fallback으로 stdioCmd
+    removeMcp(name);
+    const restoreScope = orig.scope || 'user';
+    const restoreCmd = orig.raw && orig.raw.trim() ? orig.raw.trim() : stdioCmd;
+    const success = run(`claude mcp add "${name}" -s ${restoreScope} -- ${restoreCmd}`);
+
+    if (success) {
+      console.log(`  [RESTORE] ${name} → scope=${restoreScope}`);
+      ok++;
+    } else {
+      // fallback: stdioCmd로 재시도
+      const fallback = run(`claude mcp add "${name}" -s user -- ${stdioCmd}`);
+      if (fallback) {
+        console.log(`  [FALLBACK] ${name} → stdio (원본 복원 실패, 기본값 사용)`);
+        ok++;
+      } else {
+        console.error(`  [FAIL] ${name}`);
+        fail++;
+      }
+    }
+  }
+
+  console.log(`\nDone: ${ok} restored, ${fail} failed`);
+  console.log(`Backup preserved at: ${BACKUP_FILE}`);
+}
+
+function printUsage() {
+  console.log(`Usage: node mcp-gateway-config.mjs [--enable|--disable]
+
+  --enable   Switch Claude Code MCP servers from stdio to SSE (supergateway)
+  --disable  Restore Claude Code MCP servers to original stdio mode
+
+Servers managed: ${GATEWAY_SERVERS.map((s) => s.name).join(', ')}
+Servers skipped: ${[...SKIP_SERVERS].join(', ')}`);
+}
+
+// ── main ──
+const flag = process.argv[2];
+
+if (flag === '--enable') {
+  enableSse();
+} else if (flag === '--disable') {
+  disableSse();
+} else {
+  printUsage();
+  process.exit(flag ? 1 : 0);
+}

package/scripts/mcp-gateway-ensure.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+// mcp-gateway-ensure.mjs — SessionStart 훅에서 supergateway MCP 서비스 보장
+// hub-ensure.mjs 패턴을 따름. 가볍게 헬스체크만 수행하고 필요시 기동.
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const PLUGIN_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const PID_FILE = join(tmpdir(), 'tfx-gateway-pids.json');
+const PROBE_PORT = 8100; // context7 — 첫 번째 게이트웨이 포트로 alive 프로브
+const PROBE_TIMEOUT_MS = 1500;
+const STARTUP_WAIT_MS = 4000;
+const POLL_INTERVAL_MS = 500;
+
+/**
+ * 단일 포트 /healthz 프로브로 게이트웨이 클러스터 alive 판정.
+ * 모든 포트를 체크하면 hook timeout(8s)에 걸리므로 대표 포트 1개만 확인.
+ */
+async function isGatewayAlive() {
+  try {
+    const res = await fetch(`http://127.0.0.1:${PROBE_PORT}/healthz`, {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+/** 매니페스트 파일 존재 여부로 gateway 설치 판정 (빠른 경로) */
+function hasManifest() {
+  return existsSync(PID_FILE);
+}
+
+/** mcp-gateway-start.mjs를 독립 프로세스로 기동 */
+function startGateway() {
+  const scriptPath = join(PLUGIN_ROOT, 'scripts', 'mcp-gateway-start.mjs');
+  if (!existsSync(scriptPath)) return false;
+
+  try {
+    // 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;
+  }
+}
+
+/** 게이트웨이 기동 후 프로브 포트 ready 대기 */
+async function waitForGatewayReady(maxWaitMs = STARTUP_WAIT_MS) {
+  const deadline = Date.now() + maxWaitMs;
+  while (Date.now() < deadline) {
+    if (await isGatewayAlive()) return true;
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+  }
+  return false;
+}
+
+// ── main ──
+
+// 빠른 경로: 매니페스트 존재 + 프로브 포트 살아있으면 즉시 OK
+if (hasManifest() && await isGatewayAlive()) {
+  process.stdout.write('gateway: ok');
+  process.exit(0);
+}
+
+// 매니페스트 없으면 gateway가 설정되지 않은 상태 — 조용히 스킵
+if (!hasManifest()) {
+  process.stdout.write('gateway: not configured');
+  process.exit(0);
+}
+
+// 느린 경로: 게이트웨이 기동 시도
+const started = startGateway();
+if (started) {
+  const ready = await waitForGatewayReady();
+  process.stdout.write(ready ? 'gateway: ok' : 'gateway: starting');
+} else {
+  process.stderr.write('[gateway-ensure] start failed');
+}

package/scripts/mcp-gateway-integration-test.mjs

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+// mcp-gateway-integration-test.mjs — P0 integration test for MCP Gateway
+// Usage: node scripts/mcp-gateway-integration-test.mjs
+
+import { execSync } from 'node:child_process';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPTS_DIR = dirname(fileURLToPath(import.meta.url));
+const START_SCRIPT = join(SCRIPTS_DIR, 'mcp-gateway-start.mjs');
+const CONFIG_SCRIPT = join(SCRIPTS_DIR, 'mcp-gateway-config.mjs');
+
+const HEALTH_TIMEOUT_MS = 3000;
+const STARTUP_WAIT_MS = 12000;
+const POLL_INTERVAL_MS = 500;
+
+const SERVERS = [
+  { name: 'context7',     port: 8100 },
+  { name: 'brave-search', port: 8101 },
+  { name: 'exa',          port: 8102 },
+  { name: 'tavily',       port: 8103 },
+  { name: 'jira',         port: 8104 },
+  { name: 'serena',       port: 8105 },
+  { name: 'notion',       port: 8106 },
+  { name: 'notion-guest', port: 8107 },
+];
+
+// ── utilities ──
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function checkHealth(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/healthz`, {
+      signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+function runScript(scriptPath, ...args) {
+  execSync(`node "${scriptPath}" ${args.join(' ')}`, {
+    stdio: 'inherit',
+    timeout: 30000,
+    env: { ...process.env, MSYS_NO_PATHCONV: '1' },
+  });
+}
+
+function countSupergateways() {
+  try {
+    // Write the query as a PS1 file to avoid shell quoting issues
+    const ps1 = [
+      `$procs = Get-CimInstance Win32_Process -Filter "Name='node.exe' OR Name='cmd.exe'"`,
+      `$hits = $procs | Where-Object { $_.CommandLine -match 'supergateway' }`,
+      `Write-Output $hits.Count`,
+    ].join('\n');
+    const out = execSync(
+      `powershell -NoProfile -Command "${ps1.replace(/\n/g, '; ')}"`,
+      { encoding: 'utf8', timeout: 10000, stdio: ['pipe', 'pipe', 'ignore'] },
+    );
+    return parseInt(out.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+// ── result tracking ──
+
+const results = [];
+let passed = 0;
+let failed = 0;
+
+function pass(label) {
+  console.log(`  [PASS] ${label}`);
+  results.push({ label, ok: true });
+  passed++;
+}
+
+function fail(label, detail = '') {
+  const msg = detail ? `${label} — ${detail}` : label;
+  console.log(`  [FAIL] ${msg}`);
+  results.push({ label, ok: false, detail });
+  failed++;
+}
+
+function printSummary() {
+  console.log('\n' + '='.repeat(56));
+  console.log('Integration Test Summary');
+  console.log('='.repeat(56));
+  for (const r of results) {
+    const mark = r.ok ? '\u2713' : '\u2717';
+    const detail = r.detail ? `  (${r.detail})` : '';
+    console.log(`  ${mark} ${r.label}${detail}`);
+  }
+  console.log('='.repeat(56));
+  const total = passed + failed;
+  console.log(`Result: ${passed}/${total} passed, ${failed} failed`);
+  if (failed > 0) {
+    console.log('\n[FAIL] Integration test FAILED');
+    process.exitCode = 1;
+  } else {
+    console.log('\n[PASS] Integration test PASSED');
+  }
+}
+
+// ── main ──
+
+async function main() {
+  console.log('\nMCP Gateway Integration Test');
+  console.log('='.repeat(56));
+
+  // STEP 1: Start gateways
+  console.log('\n[STEP 1] Starting gateways...');
+  try {
+    runScript(START_SCRIPT);
+    pass('Gateway start script ran without error');
+  } catch (err) {
+    fail('Gateway start script', err.message);
+    console.log('\n[ABORT] Cannot continue without gateways running');
+    printSummary();
+    return;
+  }
+
+  // STEP 2: Wait for health checks to pass (up to 12s)
+  console.log('\n[STEP 2] Waiting for health checks (up to 12s)...');
+  const deadline = Date.now() + STARTUP_WAIT_MS;
+  const pending = new Set(SERVERS.map((s) => s.port));
+
+  while (pending.size > 0 && Date.now() < deadline) {
+    await sleep(POLL_INTERVAL_MS);
+    for (const port of [...pending]) {
+      if (await checkHealth(port)) pending.delete(port);
+    }
+  }
+
+  let healthOk = 0;
+  let healthSkipped = 0;
+
+  for (const srv of SERVERS) {
+    const alive = !pending.has(srv.port);
+    if (alive) {
+      console.log(`  [ok]   ${srv.name.padEnd(16)} :${srv.port}`);
+      healthOk++;
+    } else {
+      // Servers that stay down are expected when env vars (API keys) are missing
+      console.log(`  [skip] ${srv.name.padEnd(16)} :${srv.port}  (not running — likely missing env)`);
+      healthSkipped++;
+    }
+  }
+
+  if (healthOk === 0) {
+    fail('Health check — no servers responded', `0/${SERVERS.length} up`);
+  } else {
+    pass(`Health check — ${healthOk} server(s) responding (${healthSkipped} skipped)`);
+  }
+
+  // STEP 3: Switch Claude Code config to SSE
+  console.log('\n[STEP 3] Switching Claude Code config to SSE mode...');
+  try {
+    runScript(CONFIG_SCRIPT, '--enable');
+    pass('Config switch to SSE (--enable)');
+  } catch (err) {
+    fail('Config switch to SSE', err.message);
+  }
+
+  // STEP 4: Verify SSE endpoints respond on each active port
+  console.log('\n[STEP 4] Verifying SSE endpoints (/healthz)...');
+  const sseResults = await Promise.allSettled(
+    SERVERS.map(async (srv) => ({ ...srv, alive: await checkHealth(srv.port) })),
+  );
+
+  let sseOk = 0;
+  for (const r of sseResults) {
+    if (r.status !== 'fulfilled') continue;
+    const { name, port, alive } = r.value;
+    if (alive) {
+      console.log(`  [ok]   ${name.padEnd(16)} :${port}`);
+      sseOk++;
+    } else {
+      console.log(`  [skip] ${name.padEnd(16)} :${port}  (not running)`);
+    }
+  }
+
+  if (sseOk === 0 && healthOk > 0) {
+    fail('SSE endpoint verification — servers went down after config switch');
+  } else if (sseOk > 0) {
+    pass(`SSE endpoint verification — ${sseOk} endpoint(s) healthy`);
+  } else {
+    pass('SSE endpoint verification — no servers running (all skipped due to missing env)');
+  }
+
+  // STEP 5: Restore stdio config
+  console.log('\n[STEP 5] Restoring stdio config...');
+  try {
+    runScript(CONFIG_SCRIPT, '--disable');
+    pass('Config restore to stdio (--disable)');
+  } catch (err) {
+    fail('Config restore to stdio', err.message);
+  }
+
+  // STEP 6: Stop gateways
+  console.log('\n[STEP 6] Stopping gateways...');
+  try {
+    runScript(START_SCRIPT, '--stop');
+    pass('Gateway stop script ran without error');
+  } catch (err) {
+    fail('Gateway stop script', err.message);
+  }
+
+  // STEP 7: Orphan check — brief settle, then verify no supergateway processes remain
+  console.log('\n[STEP 7] Checking for orphan supergateway processes...');
+  await sleep(2000);
+
+  const orphanCount = countSupergateways();
+  if (orphanCount === 0) {
+    pass('No orphan supergateway processes (WMI/tasklist clean)');
+  } else {
+    fail('Orphan processes found', `${orphanCount} supergateway process(es) still running`);
+  }
+
+  printSummary();
+}
+
+main();