triflux 8.2.3 → 8.3.0

package/tui/doctor.mjs

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+// tui/doctor.mjs — Interactive triflux doctor TUI
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, unlinkSync, readdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import {
+  clear, box, table, divider, label, ok, warn, fail, info,
+  select, confirm, spinner, sleep,
+  RESET, DIM, BOLD, CYAN, AMBER, GREEN, RED, YELLOW, WHITE, GRAY,
+  onExit, showCursor,
+} from "./core.mjs";
+
+const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const CLAUDE_DIR = join(homedir(), ".claude");
+const CACHE_DIR = join(CLAUDE_DIR, "cache");
+
+const CACHE_FILES = [
+  { name: "claude-usage-cache.json", desc: "Claude 사용량" },
+  { name: ".claude-refresh-lock", desc: "리프레시 락" },
+  { name: "codex-rate-limits-cache.json", desc: "Codex 레이트 리밋" },
+  { name: "gemini-quota-cache.json", desc: "Gemini 쿼터" },
+  { name: "gemini-project-id.json", desc: "Gemini 프로젝트 ID" },
+  { name: "gemini-session-cache.json", desc: "Gemini 세션" },
+  { name: "gemini-rpm-tracker.json", desc: "Gemini RPM" },
+  { name: "sv-accumulator.json", desc: "절약량 누적" },
+  { name: "mcp-inventory.json", desc: "MCP 인벤토리" },
+  { name: "cli-issues.jsonl", desc: "CLI 이슈 로그" },
+  { name: "triflux-update-check.json", desc: "업데이트 체크" },
+];
+
+// ── Run triflux doctor --json ──
+
+function runDoctor(mode = "check") {
+  const args = [join(PKG_ROOT, "bin", "triflux.mjs"), "doctor", "--json"];
+  if (mode === "fix") args.push("--fix");
+
+  try {
+    const out = execFileSync(process.execPath, args, {
+      timeout: 30000,
+      encoding: "utf8",
+      windowsHide: true,
+    });
+    // Extract JSON from output (may have ANSI/text before it)
+    const jsonMatch = out.match(/\{[\s\S]*\}$/m);
+    if (jsonMatch) return JSON.parse(jsonMatch[0]);
+  } catch (e) {
+    if (e.stdout) {
+      const jsonMatch = e.stdout.match(/\{[\s\S]*\}$/m);
+      if (jsonMatch) return JSON.parse(jsonMatch[0]);
+    }
+  }
+  return null;
+}
+
+// ── Display Results ──
+
+function statusIcon(status) {
+  const map = {
+    ok: `${GREEN}✓${RESET}`,
+    missing: `${RED}✗${RESET}`,
+    partial: `${YELLOW}⚠${RESET}`,
+    warning: `${YELLOW}⚠${RESET}`,
+    optional_missing: `${GRAY}○${RESET}`,
+  };
+  return map[status] || `${GRAY}?${RESET}`;
+}
+
+function showReport(report) {
+  if (!report) {
+    fail("진단 결과를 가져올 수 없습니다.");
+    return;
+  }
+
+  console.log();
+  const statusColor = report.issue_count === 0 ? GREEN : report.issue_count <= 2 ? YELLOW : RED;
+  label("상태", `${statusColor}${report.issue_count === 0 ? "정상" : `${report.issue_count}개 이슈`}${RESET}`);
+  label("모드", report.mode);
+  console.log();
+
+  const headers = ["항목", "상태", "비고"];
+  const rows = (report.checks || []).map((c) => {
+    let note = "";
+    if (c.version) note = `v${c.version}`;
+    if (c.missing_profiles?.length) note = `누락: ${c.missing_profiles.join(", ")}`;
+    if (c.fix) note += note ? ` → ${c.fix}` : c.fix;
+    if (c.path && !c.fix) note = c.path;
+
+    const icon = c.status === "ok" ? statusIcon("ok") :
+                 c.optional ? statusIcon("optional_missing") : statusIcon(c.status);
+
+    return [
+      `${icon} ${c.name}`,
+      c.status === "ok" ? `${GREEN}정상${RESET}` : `${RED}${c.status}${RESET}`,
+      note ? `${DIM}${note}${RESET}` : "",
+    ];
+  });
+
+  if (rows.length > 0) table(headers, rows);
+
+  // Actions (from fix/reset mode)
+  if (report.actions?.length > 0) {
+    console.log();
+    info(`수행된 작업: ${report.actions.length}개`);
+    for (const action of report.actions) {
+      const icon = action.status === "ok" ? `${GREEN}✓${RESET}` : `${RED}✗${RESET}`;
+      console.log(`    ${icon} ${action.type}: ${action.name || action.path || ""}`);
+    }
+  }
+}
+
+// ── Cache Management ──
+
+function getCacheStatus() {
+  const results = [];
+  for (const { name, desc } of CACHE_FILES) {
+    const fp = join(CACHE_DIR, name);
+    if (existsSync(fp)) {
+      let size = 0;
+      try { size = readFileSync(fp).length; } catch {}
+      let hasError = false;
+      try {
+        const parsed = JSON.parse(readFileSync(fp, "utf8"));
+        hasError = !!parsed.error;
+      } catch { hasError = true; }
+      results.push({ name, desc, exists: true, size, hasError });
+    } else {
+      results.push({ name, desc, exists: false, size: 0, hasError: false });
+    }
+  }
+  return results;
+}
+
+function showCacheStatus() {
+  const caches = getCacheStatus();
+  const existing = caches.filter((c) => c.exists);
+
+  if (existing.length === 0) {
+    info("캐시 파일 없음 (깨끗한 상태)");
+    return;
+  }
+
+  console.log();
+  const headers = ["캐시", "크기", "상태"];
+  const rows = existing.map((c) => [
+    c.desc,
+    c.size < 1024 ? `${c.size}B` : `${(c.size / 1024).toFixed(1)}KB`,
+    c.hasError ? `${RED}에러${RESET}` : `${GREEN}정상${RESET}`,
+  ]);
+  table(headers, rows);
+}
+
+async function selectiveReset() {
+  const caches = getCacheStatus().filter((c) => c.exists);
+  if (caches.length === 0) {
+    info("삭제할 캐시 파일이 없습니다.");
+    return;
+  }
+
+  const options = [
+    { label: "전체 삭제", hint: `${caches.length}개 파일` },
+    { label: "에러 캐시만 삭제", hint: "손상된 파일만" },
+    { label: "선택 삭제", hint: "하나씩 선택" },
+    { label: "취소", hint: "" },
+  ];
+
+  const choice = await select("삭제 방식", options);
+  if (!choice || choice.index === 3) return;
+
+  let targets = [];
+  if (choice.index === 0) {
+    targets = caches;
+  } else if (choice.index === 1) {
+    targets = caches.filter((c) => c.hasError);
+    if (targets.length === 0) {
+      info("에러 상태의 캐시가 없습니다.");
+      return;
+    }
+  } else {
+    for (const c of caches) {
+      const del = await confirm(`${c.desc} (${c.name}) 삭제?`, c.hasError);
+      if (del) targets.push(c);
+    }
+  }
+
+  if (targets.length === 0) return;
+
+  if (!(await confirm(`${targets.length}개 캐시 파일을 삭제하시겠습니까?`))) return;
+
+  let deleted = 0;
+  for (const c of targets) {
+    try {
+      unlinkSync(join(CACHE_DIR, c.name));
+      ok(`삭제: ${c.desc}`);
+      deleted++;
+    } catch (e) {
+      fail(`삭제 실패: ${c.desc} — ${e.message}`);
+    }
+  }
+
+  ok(`${BOLD}${deleted}개${RESET} 캐시 파일 삭제 완료`);
+}
+
+// ── Orphan Teams ──
+
+async function checkOrphanTeams() {
+  const teamsDir = join(CLAUDE_DIR, "teams");
+  if (!existsSync(teamsDir)) {
+    info("teams 디렉토리 없음");
+    return;
+  }
+
+  const entries = readdirSync(teamsDir).filter((e) => !e.startsWith("."));
+  if (entries.length === 0) {
+    ok("잔존 팀 없음");
+    return;
+  }
+
+  warn(`${entries.length}개 팀 세션 발견`);
+  for (const e of entries) {
+    console.log(`    ${DIM}${e}${RESET}`);
+  }
+
+  if (await confirm("잔존 팀 정리를 시도하시겠습니까?", false)) {
+    const spin = spinner("팀 정리 중...");
+    try {
+      // Delegate to triflux's cleanup
+      execFileSync(process.execPath, [join(PKG_ROOT, "bin", "triflux.mjs"), "doctor", "--fix"], {
+        timeout: 30000, stdio: "ignore", windowsHide: true,
+      });
+      spin.stop();
+      ok("팀 정리 완료");
+    } catch {
+      spin.stop();
+      warn("팀 정리 실패 — 수동 삭제가 필요할 수 있습니다");
+    }
+  }
+}
+
+// ── Main Menu ──
+
+const MENU = [
+  { label: "진단 (Diagnose)",       hint: "읽기 전용 검사" },
+  { label: "수정 (Fix)",            hint: "자동 수정 + 진단" },
+  { label: "캐시 관리 (Cache)",     hint: "캐시 조회/선택 삭제" },
+  { label: "팀 세션 정리 (Teams)",  hint: "잔존 팀 감지/정리" },
+  { label: "전체 초기화 (Reset)",   hint: "캐시 전체 삭제 + 재생성" },
+  { label: "종료",                  hint: "Ctrl+C" },
+];
+
+async function main() {
+  onExit(() => {});
+  clear();
+
+  while (true) {
+    box("triflux Doctor", 46);
+    console.log();
+
+    const choice = await select("작업 선택", MENU);
+    if (!choice || choice.index === 5) {
+      console.log();
+      info("종료합니다.");
+      showCursor();
+      break;
+    }
+
+    console.log();
+
+    switch (choice.index) {
+      case 0: {
+        const spin = spinner("진단 중...");
+        const report = runDoctor("check");
+        spin.stop();
+        showReport(report);
+        break;
+      }
+
+      case 1: {
+        if (!(await confirm("자동 수정을 실행하시겠습니까?"))) break;
+        const spin = spinner("수정 + 진단 중...");
+        const report = runDoctor("fix");
+        spin.stop();
+        showReport(report);
+        break;
+      }
+
+      case 2: {
+        showCacheStatus();
+        console.log();
+        await selectiveReset();
+        break;
+      }
+
+      case 3: {
+        await checkOrphanTeams();
+        break;
+      }
+
+      case 4: {
+        if (!(await confirm(`${RED}전체 캐시를 초기화${RESET}하시겠습니까?`, false))) break;
+        const spin = spinner("초기화 + 재생성 중...");
+        try {
+          execFileSync(process.execPath,
+            [join(PKG_ROOT, "bin", "triflux.mjs"), "doctor", "--reset"],
+            { timeout: 60000, encoding: "utf8", windowsHide: true }
+          );
+          spin.stop();
+          ok("전체 초기화 + 재생성 완료");
+        } catch {
+          spin.stop();
+          warn("초기화 중 일부 실패 — triflux doctor --reset으로 재시도");
+        }
+        break;
+      }
+    }
+
+    console.log();
+    divider(46);
+  }
+}
+
+main().catch((e) => {
+  showCursor();
+  console.error(e);
+  process.exit(1);
+});

package/tui/setup.mjs

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+// tui/setup.mjs — Interactive triflux setup wizard TUI
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import {
+  clear, box, table, divider, label, ok, warn, fail, info,
+  select, confirm, spinner, sleep,
+  RESET, DIM, BOLD, CYAN, AMBER, GREEN, RED, YELLOW, WHITE, GRAY,
+  onExit, showCursor,
+} from "./core.mjs";
+
+const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const CLAUDE_DIR = join(homedir(), ".claude");
+const CODEX_DIR = join(homedir(), ".codex");
+const SETTINGS_PATH = join(CLAUDE_DIR, "settings.json");
+
+// ── Step Definitions ──
+
+const STEPS = [
+  { id: "sync",     name: "파일 동기화",      desc: "스크립트/HUD/스킬을 ~/.claude/에 배포" },
+  { id: "hud",      name: "HUD 설정",         desc: "settings.json에 statusLine 등록" },
+  { id: "profiles", name: "Codex 프로파일",   desc: "필수 프로파일 생성/확인" },
+  { id: "cli",      name: "CLI 진단",         desc: "Codex/Gemini/Claude CLI 확인" },
+  { id: "mcp",      name: "MCP 서버 확인",    desc: "MCP 서버 인벤토리 점검" },
+];
+
+// ── Step Implementations ──
+
+function stepSync() {
+  try {
+    const out = execFileSync(process.execPath,
+      [join(PKG_ROOT, "bin", "triflux.mjs"), "setup", "--json"],
+      { timeout: 30000, encoding: "utf8", windowsHide: true }
+    );
+    return { ok: true, detail: "파일 동기화 완료" };
+  } catch (e) {
+    return { ok: false, detail: e.message };
+  }
+}
+
+function stepHud() {
+  try {
+    if (!existsSync(SETTINGS_PATH)) {
+      return { ok: false, detail: "settings.json 미존재", action: "create" };
+    }
+
+    const raw = readFileSync(SETTINGS_PATH, "utf8");
+    let settings;
+    try { settings = JSON.parse(raw); } catch {
+      return { ok: false, detail: "settings.json 파싱 실패", action: "fix" };
+    }
+
+    const hudScript = join(CLAUDE_DIR, "hud", "hud-qos-status.mjs");
+    const nodePath = process.execPath;
+
+    // Check if statusLine already configured correctly
+    if (settings.statusLine?.command?.includes("hud-qos-status")) {
+      return { ok: true, detail: "statusLine 이미 설정됨", current: settings.statusLine };
+    }
+
+    return {
+      ok: false,
+      detail: settings.statusLine ? "statusLine이 다른 HUD를 가리킴" : "statusLine 미설정",
+      action: "configure",
+      current: settings.statusLine || null,
+      target: {
+        type: "command",
+        command: `"${nodePath}" "${hudScript}"`,
+      },
+    };
+  } catch (e) {
+    return { ok: false, detail: e.message };
+  }
+}
+
+function stepProfiles() {
+  const configPath = join(CODEX_DIR, "config.toml");
+  if (!existsSync(configPath)) {
+    return { ok: false, detail: "config.toml 미존재", action: "skip" };
+  }
+
+  const content = readFileSync(configPath, "utf8");
+  const required = ["codex53_high", "codex53_xhigh", "spark53_low"];
+  const missing = required.filter((name) => {
+    const re = new RegExp(`^\\[profiles\\.${name}\\]`, "m");
+    return !re.test(content);
+  });
+
+  if (missing.length === 0) {
+    return { ok: true, detail: `필수 프로파일 ${required.length}개 확인됨` };
+  }
+
+  return { ok: false, detail: `누락: ${missing.join(", ")}`, missing, action: "create" };
+}
+
+function stepCli() {
+  const results = [];
+  for (const [name, installCmd] of [
+    ["codex", "npm i -g @openai/codex"],
+    ["gemini", "npm i -g @google/gemini-cli"],
+    ["claude", "Claude Code 설치"],
+  ]) {
+    try {
+      execFileSync(process.platform === "win32" ? "where" : "which", [name], {
+        timeout: 5000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"],
+      });
+      results.push({ name, found: true });
+    } catch {
+      results.push({ name, found: false, install: installCmd });
+    }
+  }
+  const allFound = results.every((r) => r.found);
+  return { ok: allFound, results, detail: allFound ? "모든 CLI 확인됨" : "일부 CLI 미설치" };
+}
+
+function stepMcp() {
+  const inventoryPath = join(CLAUDE_DIR, "cache", "mcp-inventory.json");
+  if (!existsSync(inventoryPath)) {
+    return { ok: false, detail: "MCP 인벤토리 미존재", action: "rebuild" };
+  }
+  try {
+    const inventory = JSON.parse(readFileSync(inventoryPath, "utf8"));
+    const count = Object.keys(inventory.servers || inventory).length;
+    return { ok: true, detail: `${count}개 MCP 서버 등록됨` };
+  } catch {
+    return { ok: false, detail: "MCP 인벤토리 파싱 실패", action: "rebuild" };
+  }
+}
+
+const STEP_RUNNERS = { sync: stepSync, hud: stepHud, profiles: stepProfiles, cli: stepCli, mcp: stepMcp };
+
+// ── UI ──
+
+function showStepResult(step, result) {
+  if (result.ok) {
+    ok(`${step.name}: ${result.detail}`);
+  } else {
+    warn(`${step.name}: ${result.detail}`);
+  }
+}
+
+async function runWizard() {
+  console.log();
+  info(`${STEPS.length}개 단계를 순서대로 실행합니다.`);
+  console.log();
+
+  const results = {};
+
+  for (let i = 0; i < STEPS.length; i++) {
+    const step = STEPS[i];
+    const progress = `${DIM}[${i + 1}/${STEPS.length}]${RESET}`;
+
+    console.log(`  ${progress} ${BOLD}${step.name}${RESET} ${DIM}— ${step.desc}${RESET}`);
+
+    const spin = spinner(`${step.name} 실행 중...`);
+    const result = STEP_RUNNERS[step.id]();
+    spin.stop();
+
+    showStepResult(step, result);
+    results[step.id] = result;
+
+    // Handle fixable issues
+    if (!result.ok && result.action) {
+      await handleStepFix(step, result);
+    }
+
+    console.log();
+  }
+
+  return results;
+}
+
+async function handleStepFix(step, result) {
+  switch (step.id) {
+    case "hud": {
+      if (result.action === "configure") {
+        if (result.current) {
+          warn(`현재 statusLine: ${JSON.stringify(result.current)}`);
+          if (!(await confirm("triflux HUD로 덮어쓰시겠습니까?", false))) return;
+        } else {
+          if (!(await confirm("statusLine을 설정하시겠습니까?"))) return;
+        }
+        try {
+          const raw = readFileSync(SETTINGS_PATH, "utf8");
+          const settings = JSON.parse(raw);
+          settings.statusLine = result.target;
+          writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
+          ok("statusLine 설정 완료");
+        } catch (e) {
+          fail(`설정 실패: ${e.message}`);
+        }
+      }
+      break;
+    }
+
+    case "profiles": {
+      if (result.action === "create" && result.missing) {
+        if (await confirm(`누락된 프로파일 ${result.missing.length}개를 생성하시겠습니까?`)) {
+          try {
+            execFileSync(process.execPath,
+              [join(PKG_ROOT, "bin", "triflux.mjs"), "setup"],
+              { timeout: 15000, stdio: "ignore", windowsHide: true }
+            );
+            ok("프로파일 생성 완료");
+          } catch {
+            warn("프로파일 생성 실패 — triflux setup으로 재시도");
+          }
+        }
+      }
+      break;
+    }
+
+    case "mcp": {
+      if (result.action === "rebuild") {
+        if (await confirm("MCP 인벤토리를 재생성하시겠습니까?")) {
+          const mcpCheck = join(PKG_ROOT, "scripts", "mcp-check.mjs");
+          if (existsSync(mcpCheck)) {
+            try {
+              execFileSync(process.execPath, [mcpCheck], { timeout: 15000, stdio: "ignore", windowsHide: true });
+              ok("MCP 인벤토리 재생성 완료");
+            } catch {
+              warn("MCP 인벤토리 재생성 실패 — 다음 세션에서 자동 재시도");
+            }
+          }
+        }
+      }
+      break;
+    }
+  }
+}
+
+async function runSelective() {
+  const options = STEPS.map((s) => ({
+    label: s.name,
+    hint: s.desc,
+  }));
+
+  const picked = await select("실행할 단계", options);
+  if (!picked) return;
+
+  const step = STEPS[picked.index];
+  console.log();
+  const spin = spinner(`${step.name} 실행 중...`);
+  const result = STEP_RUNNERS[step.id]();
+  spin.stop();
+
+  showStepResult(step, result);
+
+  if (!result.ok && result.action) {
+    await handleStepFix(step, result);
+  }
+
+  // CLI step has extra detail
+  if (step.id === "cli" && result.results) {
+    console.log();
+    for (const r of result.results) {
+      if (r.found) ok(`${r.name}: 설치됨`);
+      else warn(`${r.name}: 미설치 → ${DIM}${r.install}${RESET}`);
+    }
+  }
+}
+
+function showSummary(results) {
+  console.log();
+  divider(46);
+  box("Setup 완료", 46);
+  console.log();
+
+  const headers = ["항목", "상태"];
+  const rows = STEPS.map((s) => {
+    const r = results[s.id];
+    if (!r) return [s.name, `${GRAY}건너뜀${RESET}`];
+    return [
+      s.name,
+      r.ok ? `${GREEN}✓ 정상${RESET}` : `${YELLOW}⚠ ${r.detail}${RESET}`,
+    ];
+  });
+
+  table(headers, rows);
+
+  const issues = Object.values(results).filter((r) => r && !r.ok).length;
+  console.log();
+  if (issues === 0) {
+    ok(`${BOLD}모든 항목 정상${RESET} — 세션을 재시작하면 적용됩니다`);
+  } else {
+    warn(`${issues}개 항목에 주의가 필요합니다`);
+    info("/tfx-doctor --fix 로 자동 수정을 시도하세요");
+  }
+}
+
+// ── Main Menu ──
+
+const MENU = [
+  { label: "전체 설정 (Full Setup)",   hint: "5단계 순서 실행" },
+  { label: "단계별 선택 (Selective)",   hint: "특정 단계만 실행" },
+  { label: "현재 상태 확인 (Status)",   hint: "설정 없이 진단만" },
+  { label: "종료",                      hint: "Ctrl+C" },
+];
+
+async function main() {
+  onExit(() => {});
+  clear();
+
+  while (true) {
+    box("triflux Setup Wizard", 46);
+    console.log();
+
+    const choice = await select("작업 선택", MENU);
+    if (!choice || choice.index === 3) {
+      console.log();
+      info("종료합니다.");
+      showCursor();
+      break;
+    }
+
+    console.log();
+
+    switch (choice.index) {
+      case 0: {
+        const results = await runWizard();
+        showSummary(results);
+        break;
+      }
+
+      case 1: {
+        await runSelective();
+        break;
+      }
+
+      case 2: {
+        info("현재 상태를 확인합니다...");
+        console.log();
+        const results = {};
+        for (const step of STEPS) {
+          if (step.id === "sync") continue; // sync는 상태 확인 불가
+          const result = STEP_RUNNERS[step.id]();
+          showStepResult(step, result);
+          results[step.id] = result;
+          if (step.id === "cli" && result.results) {
+            for (const r of result.results) {
+              if (r.found) ok(`  ${r.name}: 설치됨`);
+              else warn(`  ${r.name}: 미설치`);
+            }
+          }
+        }
+        break;
+      }
+    }
+
+    console.log();
+    divider(46);
+  }
+}
+
+main().catch((e) => {
+  showCursor();
+  console.error(e);
+  process.exit(1);
+});