triflux 10.0.0 → 10.0.2

package/hud/constants.mjs

@@ -0,0 +1,88 @@
+// ============================================================================
+// 상수 / 경로
+// ============================================================================
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const VERSION = "2.0";
+
+export const QOS_PATH = join(homedir(), ".omc", "state", "cli_qos_profile.json");
+export const ACCOUNTS_CONFIG_PATH = join(homedir(), ".omc", "router", "accounts.json");
+export const ACCOUNTS_STATE_PATH = join(homedir(), ".omc", "state", "cli_accounts_state.json");
+
+// tfx-multi 상태 (v2.2 HUD 통합)
+export const TEAM_STATE_PATH = join(homedir(), ".claude", "cache", "tfx-hub", "team-state.json");
+export const CONTEXT_MONITOR_CACHE_PATH = join(homedir(), ".claude", "cache", "tfx-hub", "context-monitor.json");
+export const CONTEXT_MONITOR_LEGACY_PATH = join(homedir(), ".omc", "state", "context-monitor.json");
+export const CONTEXT_MONITOR_LOG_DIR = join(homedir(), ".omc", "logs");
+
+// 원격 프로브 캐시 (tfx-remote-spawn)
+export const REMOTE_ENV_CACHE_DIR = join(homedir(), ".claude", "cache", "tfx-hub", "remote-env");
+export const REMOTE_ENV_CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24시간
+
+// Claude OAuth Usage API (api.anthropic.com/api/oauth/usage)
+export const CLAUDE_CREDENTIALS_PATH = join(homedir(), ".claude", ".credentials.json");
+export const CLAUDE_USAGE_CACHE_PATH = join(homedir(), ".claude", "cache", "claude-usage-cache.json");
+export const OMC_PLUGIN_USAGE_CACHE_PATH = join(homedir(), ".claude", "plugins", "oh-my-claudecode", ".usage-cache.json");
+export const CLAUDE_USAGE_STALE_MS_SOLO = 5 * 60 * 1000; // OMC 없을 때: 5분 캐시
+export const CLAUDE_USAGE_STALE_MS_WITH_OMC = 15 * 60 * 1000; // OMC 있을 때: 15분 (OMC가 30초마다 갱신)
+export const CLAUDE_USAGE_429_BACKOFF_MS = 10 * 60 * 1000; // 429 에러 시 10분 backoff
+export const GEMINI_429_BASE_DELAY_MS = 2000;
+export const GEMINI_429_MAX_RETRIES = 3;
+export const GEMINI_429_COOLDOWN_MS = 30000;
+export const CLAUDE_USAGE_ERROR_BACKOFF_MS = 3 * 60 * 1000; // 기타 에러 시 3분 backoff
+export const CLAUDE_API_TIMEOUT_MS = 10_000;
+export const FIVE_HOUR_MS = 5 * 60 * 60 * 1000;
+export const SEVEN_DAY_MS = 7 * 24 * 60 * 60 * 1000;
+export const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+
+export const CODEX_AUTH_PATH = join(homedir(), ".codex", "auth.json");
+export const CODEX_QUOTA_CACHE_PATH = join(homedir(), ".claude", "cache", "codex-rate-limits-cache.json");
+export const CODEX_QUOTA_STALE_MS = 15 * 1000; // 15초
+export const CODEX_MIN_BUCKETS = 2;
+
+// Gemini 쿼터 API 관련
+export const GEMINI_OAUTH_PATH = join(homedir(), ".gemini", "oauth_creds.json");
+export const GEMINI_QUOTA_CACHE_PATH = join(homedir(), ".claude", "cache", "gemini-quota-cache.json");
+export const GEMINI_PROJECT_CACHE_PATH = join(homedir(), ".claude", "cache", "gemini-project-id.json");
+export const GEMINI_SESSION_CACHE_PATH = join(homedir(), ".claude", "cache", "gemini-session-cache.json");
+export const GEMINI_RPM_TRACKER_PATH = join(homedir(), ".claude", "cache", "gemini-rpm-tracker.json");
+export const SV_ACCUMULATOR_PATH = join(homedir(), ".claude", "cache", "sv-accumulator.json");
+// 이전 .omc/ 경로 fallback (기존 환경 호환)
+export const LEGACY_GEMINI_QUOTA_CACHE = join(homedir(), ".omc", "state", "gemini_quota_cache.json");
+export const LEGACY_GEMINI_PROJECT_CACHE = join(homedir(), ".omc", "state", "gemini_project_id.json");
+export const LEGACY_GEMINI_SESSION_CACHE = join(homedir(), ".omc", "state", "gemini_session_tokens_cache.json");
+export const LEGACY_GEMINI_RPM_TRACKER = join(homedir(), ".omc", "state", "gemini_rpm_tracker.json");
+export const LEGACY_SV_ACCUMULATOR = join(homedir(), ".omc", "state", "sv-accumulator.json");
+
+export const GEMINI_RPM_WINDOW_MS = 60 * 1000; // 60초 슬라이딩 윈도우
+export const GEMINI_QUOTA_STALE_MS = 5 * 60 * 1000; // 5분
+export const GEMINI_SESSION_STALE_MS = 15 * 1000; // 15초
+export const GEMINI_API_TIMEOUT_MS = 3000; // 3초
+
+export const ACCOUNT_LABEL_WIDTH = 10;
+export const PROVIDER_PREFIX_WIDTH = 2;
+export const PERCENT_CELL_WIDTH = 3;
+export const TIME_CELL_INNER_WIDTH = 6;
+export const SV_CELL_WIDTH = 5;
+
+export const CLAUDE_REFRESH_FLAG = "--refresh-claude-usage";
+export const CODEX_REFRESH_FLAG = "--refresh-codex-rate-limits";
+export const GEMINI_REFRESH_FLAG = "--refresh-gemini-quota";
+export const GEMINI_SESSION_REFRESH_FLAG = "--refresh-gemini-session";
+
+// 모바일/Termux 컴팩트 모드 감지
+export const HUD_CONFIG_PATH = join(homedir(), ".omc", "config", "hud.json");
+export const COMPACT_COLS_THRESHOLD = 80;
+export const MINIMAL_COLS_THRESHOLD = 60;
+
+// rows 임계값 상수 (selectTier 에서 tier 결정에 사용)
+export const ROWS_BUDGET_FULL = 40;
+export const ROWS_BUDGET_LARGE = 35;
+export const ROWS_BUDGET_MEDIUM = 28;
+export const ROWS_BUDGET_SMALL = 22;
+
+// Gemini Pro 풀 공유 그룹: 같은 remainingFraction을 공유하는 모델 ID들
+export const GEMINI_PRO_POOL = new Set(["gemini-2.5-pro", "gemini-3-pro-preview", "gemini-3.1-pro-preview"]);
+export const GEMINI_FLASH_POOL = new Set(["gemini-2.5-flash", "gemini-3-flash-preview"]);

package/hud/context-monitor.mjs

@@ -0,0 +1,403 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+
+import {
+  CONTEXT_MONITOR_CACHE_PATH,
+  CONTEXT_MONITOR_LEGACY_PATH,
+  CONTEXT_MONITOR_LOG_DIR,
+} from "./constants.mjs";
+import { clampPercent, formatTokenCount, readJsonMigrate } from "./utils.mjs";
+
+const DEFAULT_CONTEXT_LIMIT = 200_000;
+const MAX_CAPTURE_BYTES = 256 * 1024;
+const MAX_TOP_KEYS = 20;
+
+const WARNING_LEVELS = Object.freeze({
+  ok: { min: 0, message: "" },
+  info: { min: 60, message: "컨텍스트 절반 이상 사용" },
+  warn: { min: 80, message: "압축 권장" },
+  critical: { min: 90, message: "에이전트 분할 또는 세션 교체 권장" },
+});
+
+// Unlike clampPercent (rounds), this preserves decimals for precise threshold comparison.
+function clampThresholdPercent(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return 0;
+  return Math.max(0, Math.min(100, numeric));
+}
+
+function safeWriteJson(filePath, data) {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+  } catch {
+    // noop
+  }
+}
+
+function normalizeText(input) {
+  if (typeof input === "string") return input;
+  if (input == null) return "";
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+
+function safeJsonParse(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function toTokenEstimate(bytesOrText) {
+  if (typeof bytesOrText === "number" && Number.isFinite(bytesOrText)) {
+    if (bytesOrText <= 0) return 0;
+    return Math.max(1, Math.ceil(bytesOrText / 4));
+  }
+  const text = normalizeText(bytesOrText);
+  const bytes = Buffer.byteLength(text, "utf8");
+  if (bytes <= 0) return 0;
+  return Math.max(1, Math.ceil(bytes / 4));
+}
+
+function normalizeUsage(usage) {
+  if (!usage || typeof usage !== "object") return null;
+  const input = Number(usage.input_tokens ?? usage.inputTokens ?? 0);
+  const output = Number(usage.output_tokens ?? usage.outputTokens ?? 0);
+  const cacheCreation = Number(
+    usage.cache_creation_input_tokens
+      ?? usage.cacheCreationInputTokens
+      ?? usage.cache_creation_tokens
+      ?? 0,
+  );
+  const cacheRead = Number(
+    usage.cache_read_input_tokens
+      ?? usage.cacheReadInputTokens
+      ?? usage.cache_read_tokens
+      ?? 0,
+  );
+  const totalCandidate = Number(usage.total_tokens ?? usage.totalTokens ?? Number.NaN);
+  const total = Number.isFinite(totalCandidate) && totalCandidate > 0
+    ? totalCandidate
+    : input + output + cacheCreation + cacheRead;
+  if (!Number.isFinite(total) || total <= 0) return null;
+  return {
+    input: Math.max(0, Math.round(input)),
+    output: Math.max(0, Math.round(output)),
+    cacheCreation: Math.max(0, Math.round(cacheCreation)),
+    cacheRead: Math.max(0, Math.round(cacheRead)),
+    total: Math.max(0, Math.round(total)),
+  };
+}
+
+function extractUsage(payload) {
+  if (!payload || typeof payload !== "object") return null;
+
+  const queue = [payload];
+  const seen = new Set();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || typeof current !== "object") continue;
+    if (seen.has(current)) continue;
+    seen.add(current);
+
+    const directUsage = normalizeUsage(current.usage);
+    if (directUsage) return directUsage;
+
+    if (Array.isArray(current.content)) {
+      for (const item of current.content) queue.push(item);
+    }
+
+    for (const key of ["result", "payload", "response", "message", "data"]) {
+      if (current[key] && typeof current[key] === "object") {
+        queue.push(current[key]);
+      }
+    }
+  }
+  return null;
+}
+
+function bumpCounter(target, key, tokens) {
+  if (!key) return;
+  const prev = target[key] || 0;
+  target[key] = prev + tokens;
+}
+
+function pushTopKeys(inputMap, maxKeys = MAX_TOP_KEYS) {
+  const entries = Object.entries(inputMap || {});
+  entries.sort((a, b) => b[1] - a[1]);
+  return Object.fromEntries(entries.slice(0, maxKeys));
+}
+
+function extractFileKeys(args) {
+  if (!args || typeof args !== "object") return [];
+  const out = [];
+  const add = (value) => {
+    if (typeof value !== "string" || !value.trim()) return;
+    out.push(value.trim());
+  };
+  add(args.path);
+  add(args.file);
+  add(args.filename);
+  add(args.relative_path);
+  add(args.requestFilePath);
+  add(args.responseFilePath);
+  if (Array.isArray(args.paths)) {
+    for (const p of args.paths) add(p);
+  }
+  return Array.from(new Set(out)).slice(0, 5);
+}
+
+function detectSkillHints(payloadText) {
+  if (!payloadText) return [];
+  const matches = payloadText.match(/\$[a-z0-9_-]+/gi) || [];
+  return Array.from(new Set(matches.map((m) => m.replace(/^\$/, "")))).slice(0, 5);
+}
+
+export function estimateTokens(input) {
+  return toTokenEstimate(input);
+}
+
+export function parseUsageFromPayload(payload) {
+  return extractUsage(payload);
+}
+
+export function classifyContextThreshold(percent) {
+  const p = clampThresholdPercent(percent);
+  if (p >= WARNING_LEVELS.critical.min) return { level: "critical", message: WARNING_LEVELS.critical.message };
+  if (p >= WARNING_LEVELS.warn.min) return { level: "warn", message: WARNING_LEVELS.warn.message };
+  if (p >= WARNING_LEVELS.info.min) return { level: "info", message: WARNING_LEVELS.info.message };
+  return { level: "ok", message: "" };
+}
+
+export function formatContextUsage(usedTokens, limitTokens, percent = null) {
+  const used = Math.max(0, Math.round(Number(usedTokens) || 0));
+  const limit = Math.max(1, Math.round(Number(limitTokens) || DEFAULT_CONTEXT_LIMIT));
+  const pct = percent == null ? clampPercent((used / limit) * 100) : clampPercent(percent);
+  return `${formatTokenCount(used)}/${formatTokenCount(limit)} (${pct}%)`;
+}
+
+export function readContextMonitorSnapshot() {
+  return readJsonMigrate(CONTEXT_MONITOR_CACHE_PATH, CONTEXT_MONITOR_LEGACY_PATH, null);
+}
+
+function getStdinContextUsage(stdin) {
+  const limitTokens = Number(stdin?.context_window?.context_window_size || 0);
+  const nativePercent = Number(stdin?.context_window?.used_percentage);
+  const usage = stdin?.context_window?.current_usage || {};
+  const explicitUsed = Number(usage.total_tokens || 0);
+  const calculatedUsed = Number(usage.input_tokens || 0)
+    + Number(usage.cache_creation_input_tokens || 0)
+    + Number(usage.cache_read_input_tokens || 0);
+  const usedTokens = explicitUsed > 0 ? explicitUsed : calculatedUsed;
+
+  if (limitTokens > 0 && usedTokens > 0) {
+    return {
+      usedTokens: Math.round(usedTokens),
+      limitTokens: Math.round(limitTokens),
+      percent: clampPercent((usedTokens / limitTokens) * 100),
+      source: "stdin.tokens",
+    };
+  }
+
+  if (limitTokens > 0 && Number.isFinite(nativePercent)) {
+    const percent = clampPercent(nativePercent);
+    return {
+      usedTokens: Math.round((limitTokens * percent) / 100),
+      limitTokens: Math.round(limitTokens),
+      percent,
+      source: "stdin.percent",
+    };
+  }
+  return null;
+}
+
+export function buildContextUsageView(stdin, snapshot = null) {
+  const stdinUsage = getStdinContextUsage(stdin);
+  const monitor = snapshot || readContextMonitorSnapshot();
+  const fallbackLimit = Number(monitor?.limitTokens || DEFAULT_CONTEXT_LIMIT);
+
+  const usedTokens = stdinUsage?.usedTokens
+    ?? Number(monitor?.usedTokens || 0);
+  const limitTokens = stdinUsage?.limitTokens
+    ?? Math.max(1, fallbackLimit);
+  const percent = stdinUsage?.percent
+    ?? (limitTokens > 0 ? clampPercent((usedTokens / limitTokens) * 100) : 0);
+
+  const warning = classifyContextThreshold(percent);
+  return {
+    usedTokens,
+    limitTokens,
+    percent,
+    display: formatContextUsage(usedTokens, limitTokens, percent),
+    warningLevel: warning.level,
+    warningMessage: warning.message,
+    warningTag: warning.level === "warn" ? "⚠ 압축 권장"
+      : warning.level === "critical" ? "‼ 분할 권장"
+      : warning.level === "info" ? "ℹ 절반 이상 사용"
+      : "",
+    source: stdinUsage?.source || (monitor ? "monitor" : "none"),
+  };
+}
+
+export function createContextMonitor(options = {}) {
+  const limitTokens = Number(options.limitTokens || DEFAULT_CONTEXT_LIMIT);
+  const cachePath = options.cachePath || CONTEXT_MONITOR_CACHE_PATH;
+  const logsDir = options.logsDir || CONTEXT_MONITOR_LOG_DIR;
+  const sessionId = options.sessionId || randomUUID().slice(0, 8);
+  const registerExitHooks = options.registerExitHooks !== false;
+
+  const state = {
+    sessionId,
+    startedAt: new Date().toISOString(),
+    updatedAt: null,
+    limitTokens,
+    usedTokens: 0,
+    requestTokens: 0,
+    responseTokens: 0,
+    exactUsageTokens: 0,
+    totalUpdates: 0,
+    maxPercent: 0,
+    warningLevel: "ok",
+    warningMessage: "",
+    bySkill: {},
+    byFile: {},
+    byTool: {},
+  };
+
+  const writeSnapshot = () => {
+    const percent = clampPercent((state.usedTokens / state.limitTokens) * 100);
+    const warning = classifyContextThreshold(percent);
+    state.maxPercent = Math.max(state.maxPercent, percent);
+    state.warningLevel = warning.level;
+    state.warningMessage = warning.message;
+    state.updatedAt = new Date().toISOString();
+    safeWriteJson(cachePath, {
+      ...state,
+      display: formatContextUsage(state.usedTokens, state.limitTokens, percent),
+      percent,
+      bySkill: pushTopKeys(state.bySkill),
+      byFile: pushTopKeys(state.byFile),
+      byTool: pushTopKeys(state.byTool),
+    });
+    return { percent, warning };
+  };
+
+  const writeReport = (reason = "shutdown") => {
+    const percent = clampPercent((state.usedTokens / state.limitTokens) * 100);
+    const warning = classifyContextThreshold(percent);
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const reportPath = join(logsDir, `context-usage-${state.sessionId}-${ts}.json`);
+    safeWriteJson(reportPath, {
+      sessionId: state.sessionId,
+      reason,
+      startedAt: state.startedAt,
+      endedAt: new Date().toISOString(),
+      summary: {
+        usedTokens: state.usedTokens,
+        limitTokens: state.limitTokens,
+        percent,
+        warningLevel: warning.level,
+        warningMessage: warning.message,
+        requestTokens: state.requestTokens,
+        responseTokens: state.responseTokens,
+        exactUsageTokens: state.exactUsageTokens,
+        updates: state.totalUpdates,
+      },
+      breakdown: {
+        skills: pushTopKeys(state.bySkill),
+        files: pushTopKeys(state.byFile),
+        tools: pushTopKeys(state.byTool),
+      },
+    });
+    return reportPath;
+  };
+
+  const record = ({
+    requestBody = null,
+    requestBytes = 0,
+    responseBody = null,
+    responseBytes = 0,
+    toolName = "",
+  } = {}) => {
+    const started = process.hrtime.bigint();
+    const reqObj = typeof requestBody === "object" ? requestBody : safeJsonParse(String(requestBody || ""));
+    const resObj = typeof responseBody === "object" ? responseBody : safeJsonParse(String(responseBody || ""));
+
+    const usage = parseUsageFromPayload(resObj);
+    const requestTokens = requestBytes > 0 ? toTokenEstimate(requestBytes) : toTokenEstimate(requestBody);
+    const responseTokens = usage?.total ?? (responseBytes > 0 ? toTokenEstimate(responseBytes) : toTokenEstimate(responseBody));
+    const totalTokens = Math.max(0, requestTokens + responseTokens);
+
+    const method = reqObj?.method || reqObj?.params?.name || "";
+    const name = toolName || reqObj?.params?.name || reqObj?.tool || "";
+    const args = reqObj?.params?.arguments || reqObj?.arguments || reqObj?.params || {};
+    const payloadText = normalizeText(requestBody).slice(0, MAX_CAPTURE_BYTES);
+    const skills = detectSkillHints(payloadText);
+    const files = extractFileKeys(args);
+
+    if (name) bumpCounter(state.byTool, String(name), totalTokens);
+    if (method?.includes("tool")) {
+      bumpCounter(state.byTool, String(method), totalTokens);
+    }
+    for (const file of files) bumpCounter(state.byFile, file, totalTokens);
+    for (const skill of skills) bumpCounter(state.bySkill, skill, totalTokens);
+
+    state.requestTokens += requestTokens;
+    state.responseTokens += responseTokens;
+    state.exactUsageTokens += usage?.total || 0;
+    state.usedTokens += totalTokens;
+    state.totalUpdates += 1;
+
+    const { percent, warning } = writeSnapshot();
+    const overheadMs = Number(process.hrtime.bigint() - started) / 1_000_000;
+
+    return {
+      requestTokens,
+      responseTokens,
+      totalTokens,
+      usedTokens: state.usedTokens,
+      limitTokens: state.limitTokens,
+      percent,
+      warningLevel: warning.level,
+      warningMessage: warning.message,
+      display: formatContextUsage(state.usedTokens, state.limitTokens, percent),
+      overheadMs: Math.round(overheadMs * 1000) / 1000,
+    };
+  };
+
+  let reportWritten = false;
+  const flush = (reason = "shutdown") => {
+    if (reportWritten) return null;
+    reportWritten = true;
+    return writeReport(reason);
+  };
+
+  if (registerExitHooks) {
+    const flushOnExit = () => {
+      try { flush("process.exit"); } catch {}
+    };
+    process.once("exit", flushOnExit);
+    process.once("SIGINT", flushOnExit);
+    process.once("SIGTERM", flushOnExit);
+  }
+
+  return {
+    record,
+    flush,
+    snapshot: () => ({
+      ...state,
+      bySkill: pushTopKeys(state.bySkill),
+      byFile: pushTopKeys(state.byFile),
+      byTool: pushTopKeys(state.byTool),
+    }),
+  };
+}