@triflux/core 10.0.3 → 10.25.1

package/hud/providers/codex.mjs

@@ -1,21 +1,52 @@
 // ============================================================================
 // Codex rate limits 추출 / 캐싱
 // ============================================================================
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { spawn } from "node:child_process";
 import {
-  CODEX_AUTH_PATH, CODEX_QUOTA_CACHE_PATH, CODEX_QUOTA_STALE_MS,
-  CODEX_MIN_BUCKETS, CODEX_REFRESH_FLAG,
+  CODEX_AUTH_PATH,
+  CODEX_MIN_BUCKETS,
+  CODEX_QUOTA_CACHE_PATH,
+  CODEX_QUOTA_STALE_MS,
+  CODEX_REFRESH_FLAG,
+  CODEX_REFRESH_LOCK_PATH,
+  SPAWN_LOCK_TTL_MS,
 } from "../constants.mjs";
-import { readJson, writeJsonSafe, decodeJwtEmail } from "../utils.mjs";
+import { decodeJwtEmail, readJson, writeJsonSafe } from "../utils.mjs";
+
+// window_minutes 기반 5h/1w 슬롯 분류
+// 5h: ≤360min (300min 표준, ±20% 허용)
+// weekly: ≥7000min (10080min 표준, ~5d 이상만 허용 — 24h/48h 등 중간 버킷 도입 시 silent 오분류 방지)
+export function classifyBucket(bucket) {
+  if (!bucket?.window_minutes) return null;
+  if (bucket.window_minutes <= 360) return "five_hour";
+  if (bucket.window_minutes >= 7000) return "weekly";
+  return null;
+}
+
+// primary/secondary를 window_minutes 기준으로 정규화
+// HUD 규약: primary=5h, secondary=1w
+export function normalizeBuckets(rl) {
+  let primary = null;
+  let secondary = null;
+  for (const bucket of [rl.primary, rl.secondary].filter(Boolean)) {
+    const kind = classifyBucket(bucket);
+    if (kind === "five_hour") primary = bucket;
+    else if (kind === "weekly") secondary = bucket;
+  }
+  return { primary, secondary };
+}
 
 export function getCodexEmail() {
   try {
     const auth = JSON.parse(readFileSync(CODEX_AUTH_PATH, "utf-8"));
     return decodeJwtEmail(auth?.tokens?.id_token);
-  } catch { return null; }
+  } catch {
+    return null;
+  }
 }
 
 // resets_at이 지난 윈도우의 used_percent를 0으로 보정
@@ -24,13 +55,22 @@ export function expireStaleCodexBuckets(buckets) {
   const nowSec = Math.floor(Date.now() / 1000);
   const result = {};
   for (const [key, bucket] of Object.entries(buckets)) {
-    if (!bucket) { result[key] = bucket; continue; }
+    if (!bucket) {
+      result[key] = bucket;
+      continue;
+    }
     let updated = bucket;
     if (bucket.primary?.resets_at && bucket.primary.resets_at <= nowSec) {
-      updated = { ...updated, primary: { ...updated.primary, used_percent: 0 } };
+      updated = {
+        ...updated,
+        primary: { ...updated.primary, used_percent: 0 },
+      };
     }
     if (bucket.secondary?.resets_at && bucket.secondary.resets_at <= nowSec) {
-      updated = { ...updated, secondary: { ...updated.secondary, used_percent: 0 } };
+      updated = {
+        ...updated,
+        secondary: { ...updated.secondary, used_percent: 0 },
+      };
     }
     result[key] = updated;
   }
@@ -51,15 +91,23 @@ export function getCodexRateLimits() {
   for (let dayOffset = 0; dayOffset <= 6; dayOffset++) {
     const d = new Date(now.getTime() - dayOffset * 86_400_000);
     const sessDir = join(
-      homedir(), ".codex", "sessions",
+      homedir(),
+      ".codex",
+      "sessions",
       String(d.getFullYear()),
       String(d.getMonth() + 1).padStart(2, "0"),
       String(d.getDate()).padStart(2, "0"),
     );
     if (!existsSync(sessDir)) continue;
     let files;
-    try { files = readdirSync(sessDir).filter((f) => f.endsWith(".jsonl")).sort().reverse(); }
-    catch { continue; }
+    try {
+      files = readdirSync(sessDir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .sort()
+        .reverse();
+    } catch {
+      continue;
+    }
 
     const mergedBuckets = {};
     for (const file of files) {
@@ -71,35 +119,50 @@ export function getCodexRateLimits() {
             const evt = JSON.parse(line);
             const rl = evt?.payload?.rate_limits;
             if (rl?.limit_id && !mergedBuckets[rl.limit_id]) {
-              // 실제 rate_limits: limit_id별 최신 이벤트만 기록
+              // window_minutes 기준으로 5h/1w 슬롯 정규화
+              const { primary, secondary } = normalizeBuckets(rl);
               mergedBuckets[rl.limit_id] = {
-                limitId: rl.limit_id, limitName: rl.limit_name,
-                primary: rl.primary, secondary: rl.secondary,
+                limitId: rl.limit_id,
+                limitName: rl.limit_name,
+                primary,
+                secondary,
                 credits: rl.credits,
                 tokens: evt.payload?.info?.total_token_usage,
                 contextWindow: evt.payload?.info?.model_context_window,
                 timestamp: evt.timestamp,
               };
-            } else if (dayOffset <= 1 && !rl && evt?.payload?.info?.total_token_usage && !syntheticBucket) {
+            } else if (
+              dayOffset <= 1 &&
+              !rl &&
+              evt?.payload?.info?.total_token_usage &&
+              !syntheticBucket
+            ) {
               // 2일 이내 token_count: 합성 버킷 (rate_limits가 null일 때 행 활성화용, stale 방지)
               syntheticBucket = {
-                limitId: "codex", limitName: "codex-session",
-                primary: null, secondary: null,
+                limitId: "codex",
+                limitName: "codex-session",
+                primary: null,
+                secondary: null,
                 credits: null,
                 tokens: evt.payload.info.total_token_usage,
                 contextWindow: evt.payload.info.model_context_window,
                 timestamp: evt.timestamp,
               };
             }
-          } catch { /* 라인 파싱 실패 무시 */ }
+          } catch {
+            /* 라인 파싱 실패 무시 */
+          }
           if (Object.keys(mergedBuckets).length >= CODEX_MIN_BUCKETS) break;
         }
-      } catch { /* 파일 읽기 실패 무시 */ }
+      } catch {
+        /* 파일 읽기 실패 무시 */
+      }
     }
     // 실제 rate_limits 발견 → 토큰 데이터 병합 후 즉시 반환
     if (Object.keys(mergedBuckets).length > 0) {
       if (syntheticBucket) {
-        const main = mergedBuckets.codex || mergedBuckets[Object.keys(mergedBuckets)[0]];
+        const main =
+          mergedBuckets.codex || mergedBuckets[Object.keys(mergedBuckets)[0]];
         if (main && !main.tokens) main.tokens = syntheticBucket.tokens;
       }
       expireStaleCodexBuckets(mergedBuckets);
@@ -132,6 +195,18 @@ export function refreshCodexRateLimitsCache() {
 export function scheduleCodexRateLimitRefresh() {
   const scriptPath = process.argv[1];
   if (!scriptPath) return;
+
+  // 스폰 락: 30초 내 이미 스폰했으면 중복 방지
+  try {
+    if (existsSync(CODEX_REFRESH_LOCK_PATH)) {
+      const lockAge = Date.now() - readJson(CODEX_REFRESH_LOCK_PATH, {}).t;
+      if (lockAge < SPAWN_LOCK_TTL_MS) return;
+    }
+    writeJsonSafe(CODEX_REFRESH_LOCK_PATH, { t: Date.now() });
+  } catch {
+    /* 락 실패 무시 — 스폰 진행 */
+  }
+
   try {
     const child = spawn(process.execPath, [scriptPath, CODEX_REFRESH_FLAG], {
       detached: true,

package/hud/providers/gemini.mjs

@@ -1,30 +1,47 @@
 // ============================================================================
 // Gemini 쿼터 API / 세션 토큰 / RPM 트래커
 // ============================================================================
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import https from "node:https";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import https from "node:https";
-import { spawn } from "node:child_process";
 import {
-  GEMINI_OAUTH_PATH, GEMINI_QUOTA_CACHE_PATH, GEMINI_PROJECT_CACHE_PATH,
-  GEMINI_SESSION_CACHE_PATH, GEMINI_RPM_TRACKER_PATH,
-  LEGACY_GEMINI_QUOTA_CACHE, LEGACY_GEMINI_PROJECT_CACHE,
-  LEGACY_GEMINI_SESSION_CACHE, LEGACY_GEMINI_RPM_TRACKER,
-  GEMINI_RPM_WINDOW_MS, GEMINI_QUOTA_STALE_MS, GEMINI_SESSION_STALE_MS,
   GEMINI_API_TIMEOUT_MS,
-  GEMINI_REFRESH_FLAG, GEMINI_SESSION_REFRESH_FLAG,
+  GEMINI_OAUTH_PATH,
+  GEMINI_PROJECT_CACHE_PATH,
+  GEMINI_QUOTA_CACHE_PATH,
+  GEMINI_QUOTA_REFRESH_LOCK_PATH,
+  GEMINI_QUOTA_STALE_MS,
+  GEMINI_REFRESH_FLAG,
+  GEMINI_RPM_TRACKER_PATH,
+  GEMINI_RPM_WINDOW_MS,
+  GEMINI_SESSION_CACHE_PATH,
+  GEMINI_SESSION_REFRESH_FLAG,
+  GEMINI_SESSION_REFRESH_LOCK_PATH,
+  GEMINI_SESSION_STALE_MS,
+  LEGACY_GEMINI_PROJECT_CACHE,
+  LEGACY_GEMINI_QUOTA_CACHE,
+  LEGACY_GEMINI_RPM_TRACKER,
+  LEGACY_GEMINI_SESSION_CACHE,
+  SPAWN_LOCK_TTL_MS,
 } from "../constants.mjs";
 import {
-  readJson, writeJsonSafe, readJsonMigrate, makeHash, clampPercent,
-  decodeJwtEmail, createHttpsPost,
+  clampPercent,
+  createHttpsPost,
+  decodeJwtEmail,
+  makeHash,
+  readJson,
+  readJsonMigrate,
+  writeJsonSafe,
 } from "../utils.mjs";
 
 const httpsPost = createHttpsPost(https, GEMINI_API_TIMEOUT_MS);
 
 // Gemini 모델별 RPM 한도 (실측 기반: Pro 25, Flash 300)
 export function getGeminiRpmLimit(model) {
-  if (model && model.includes("pro")) return 25;
+  if (model?.includes("pro")) return 25;
   return 300; // Flash 기본
 }
 
@@ -48,21 +65,36 @@ export function deriveGeminiLimits(bucket) {
   if (bucket.remainingAmount != null) {
     const remaining = parseInt(bucket.remainingAmount, 10);
     const limit = fraction > 0 ? Math.round(remaining / fraction) : 0;
-    return { usedPct, remaining, limit, resetTime: bucket.resetTime, modelId: bucket.modelId };
+    return {
+      usedPct,
+      remaining,
+      limit,
+      resetTime: bucket.resetTime,
+      modelId: bucket.modelId,
+    };
   }
-  return { usedPct, remaining: null, limit: null, resetTime: bucket.resetTime, modelId: bucket.modelId };
+  return {
+    usedPct,
+    remaining: null,
+    limit: null,
+    resetTime: bucket.resetTime,
+    modelId: bucket.modelId,
+  };
 }
 
 export function getGeminiEmail() {
   try {
     const oauth = readJson(GEMINI_OAUTH_PATH, null);
     return decodeJwtEmail(oauth?.id_token);
-  } catch { return null; }
+  } catch {
+    return null;
+  }
 }
 
 export function buildGeminiAuthContext(accountId) {
   const oauth = readJson(GEMINI_OAUTH_PATH, null);
-  const tokenSource = oauth?.refresh_token || oauth?.id_token || oauth?.access_token || "";
+  const tokenSource =
+    oauth?.refresh_token || oauth?.id_token || oauth?.access_token || "";
   const tokenFingerprint = tokenSource ? makeHash(tokenSource) : "none";
   const cacheKey = `${accountId || "gemini-main"}::${tokenFingerprint}`;
   return { oauth, tokenFingerprint, cacheKey };
@@ -77,11 +109,17 @@ export async function fetchGeminiQuota(accountId, options = {}) {
   const forceRefresh = options.forceRefresh === true;
 
   // 1. 캐시 확인 (계정/토큰별)
-  const cache = readJsonMigrate(GEMINI_QUOTA_CACHE_PATH, LEGACY_GEMINI_QUOTA_CACHE, null);
-  if (!forceRefresh
-    && cache?.cacheKey === cacheKey
-    && cache?.timestamp
-    && (Date.now() - cache.timestamp < GEMINI_QUOTA_STALE_MS)) {
+  const cache = readJsonMigrate(
+    GEMINI_QUOTA_CACHE_PATH,
+    LEGACY_GEMINI_QUOTA_CACHE,
+    null,
+  );
+  if (
+    !forceRefresh &&
+    cache?.cacheKey === cacheKey &&
+    cache?.timestamp &&
+    Date.now() - cache.timestamp < GEMINI_QUOTA_STALE_MS
+  ) {
     return cache;
   }
 
@@ -116,12 +154,22 @@ export async function fetchGeminiQuota(accountId, options = {}) {
       oauth.access_token,
     );
     const id = loadRes?.cloudaicompanionProject;
-    if (id) writeJsonSafe(GEMINI_PROJECT_CACHE_PATH, { cacheKey, projectId: id, timestamp: Date.now() });
+    if (id)
+      writeJsonSafe(GEMINI_PROJECT_CACHE_PATH, {
+        cacheKey,
+        projectId: id,
+        timestamp: Date.now(),
+      });
     return id || null;
   };
 
-  const projCache = readJsonMigrate(GEMINI_PROJECT_CACHE_PATH, LEGACY_GEMINI_PROJECT_CACHE, null);
-  let projectId = projCache?.cacheKey === cacheKey ? projCache?.projectId : null;
+  const projCache = readJsonMigrate(
+    GEMINI_PROJECT_CACHE_PATH,
+    LEGACY_GEMINI_PROJECT_CACHE,
+    null,
+  );
+  let projectId =
+    projCache?.cacheKey === cacheKey ? projCache?.projectId : null;
   if (!projectId) projectId = await fetchProjectId();
   if (!projectId) return cache;
 
@@ -145,7 +193,11 @@ export async function fetchGeminiQuota(accountId, options = {}) {
 
   if (!quotaRes?.buckets) {
     // API 응답에 buckets 없음: 에러 코드 또는 응답 내용을 캐시에 기록
-    const apiError = quotaRes?.error?.message || quotaRes?.error?.code || quotaRes?.error || "no buckets in response";
+    const apiError =
+      quotaRes?.error?.message ||
+      quotaRes?.error?.code ||
+      quotaRes?.error ||
+      "no buckets in response";
     writeJsonSafe(GEMINI_QUOTA_CACHE_PATH, {
       ...(cache || {}),
       timestamp: cache?.timestamp || Date.now(),
@@ -175,12 +227,17 @@ export async function fetchGeminiQuota(accountId, options = {}) {
 export function readGeminiRpm(model) {
   try {
     // 새 경로 → 레거시 경로 fallback
-    const rpmPath = existsSync(GEMINI_RPM_TRACKER_PATH) ? GEMINI_RPM_TRACKER_PATH
-      : existsSync(LEGACY_GEMINI_RPM_TRACKER) ? LEGACY_GEMINI_RPM_TRACKER : null;
+    const rpmPath = existsSync(GEMINI_RPM_TRACKER_PATH)
+      ? GEMINI_RPM_TRACKER_PATH
+      : existsSync(LEGACY_GEMINI_RPM_TRACKER)
+        ? LEGACY_GEMINI_RPM_TRACKER
+        : null;
     if (!rpmPath) return { count: 0, percent: 0, remainingSec: 60 };
     const raw = readFileSync(rpmPath, "utf-8");
     const parsed = JSON.parse(raw);
-    const timestamps = Array.isArray(parsed.timestamps) ? parsed.timestamps : [];
+    const timestamps = Array.isArray(parsed.timestamps)
+      ? parsed.timestamps
+      : [];
     const now = Date.now();
     const recent = timestamps.filter((t) => now - t < GEMINI_RPM_WINDOW_MS);
     const count = recent.length;
@@ -188,9 +245,15 @@ export function readGeminiRpm(model) {
     const percent = clampPercent(Math.round((count / rpmLimit) * 100));
     // 가장 오래된 엔트리가 윈도우에서 빠지기까지 남은 초 (0건이면 0s)
     // 5초 단위 반올림으로 HUD 깜빡임 감소
-    const rawRemainingSec = recent.length > 0
-      ? Math.max(0, Math.ceil((GEMINI_RPM_WINDOW_MS - (now - Math.min(...recent))) / 1000))
-      : 0;
+    const rawRemainingSec =
+      recent.length > 0
+        ? Math.max(
+            0,
+            Math.ceil(
+              (GEMINI_RPM_WINDOW_MS - (now - Math.min(...recent))) / 1000,
+            ),
+          )
+        : 0;
     const remainingSec = Math.ceil(rawRemainingSec / 5) * 5;
     return { count, percent, remainingSec };
   } catch {
@@ -199,7 +262,11 @@ export function readGeminiRpm(model) {
 }
 
 export function readGeminiQuotaSnapshot(accountId, authContext) {
-  const cache = readJsonMigrate(GEMINI_QUOTA_CACHE_PATH, LEGACY_GEMINI_QUOTA_CACHE, null);
+  const cache = readJsonMigrate(
+    GEMINI_QUOTA_CACHE_PATH,
+    LEGACY_GEMINI_QUOTA_CACHE,
+    null,
+  );
   if (!cache?.buckets) {
     return { quota: null, shouldRefresh: true };
   }
@@ -208,19 +275,24 @@ export function readGeminiQuotaSnapshot(accountId, authContext) {
   const isLegacyCache = !cache.cacheKey;
   const keyMatched = cache.cacheKey === cacheKey;
   const cacheTs = Number(cache.timestamp);
-  const ageMs = Number.isFinite(cacheTs) ? Date.now() - cacheTs : Number.MAX_SAFE_INTEGER;
+  const ageMs = Number.isFinite(cacheTs)
+    ? Date.now() - cacheTs
+    : Number.MAX_SAFE_INTEGER;
   const isFresh = ageMs < GEMINI_QUOTA_STALE_MS;
 
   if (keyMatched) {
     // resetTime이 지난 버킷의 remainingFraction을 1로 보정 (stale 캐시 방지)
     if (Array.isArray(cache.buckets)) {
       const now = Date.now();
-      const patchedBuckets = cache.buckets.map(b =>
+      const patchedBuckets = cache.buckets.map((b) =>
         b?.resetTime && new Date(b.resetTime).getTime() <= now
           ? { ...b, remainingFraction: 1 }
-          : b
+          : b,
       );
-      return { quota: { ...cache, buckets: patchedBuckets }, shouldRefresh: !isFresh };
+      return {
+        quota: { ...cache, buckets: patchedBuckets },
+        shouldRefresh: !isFresh,
+      };
     }
     return { quota: cache, shouldRefresh: !isFresh };
   }
@@ -233,10 +305,28 @@ export function readGeminiQuotaSnapshot(accountId, authContext) {
 export function scheduleGeminiQuotaRefresh(accountId) {
   const scriptPath = process.argv[1];
   if (!scriptPath) return;
+
+  // 스폰 락: 30초 내 이미 스폰했으면 중복 방지
+  try {
+    if (existsSync(GEMINI_QUOTA_REFRESH_LOCK_PATH)) {
+      const lockAge =
+        Date.now() - readJson(GEMINI_QUOTA_REFRESH_LOCK_PATH, {}).t;
+      if (lockAge < SPAWN_LOCK_TTL_MS) return;
+    }
+    writeJsonSafe(GEMINI_QUOTA_REFRESH_LOCK_PATH, { t: Date.now() });
+  } catch {
+    /* 락 실패 무시 — 스폰 진행 */
+  }
+
   try {
     const child = spawn(
       process.execPath,
-      [scriptPath, GEMINI_REFRESH_FLAG, "--account", accountId || "gemini-main"],
+      [
+        scriptPath,
+        GEMINI_REFRESH_FLAG,
+        "--account",
+        accountId || "gemini-main",
+      ],
       {
         detached: true,
         stdio: "ignore",
@@ -255,7 +345,11 @@ export function scheduleGeminiQuotaRefresh(accountId) {
 }
 
 export function readGeminiSessionSnapshot() {
-  const cache = readJsonMigrate(GEMINI_SESSION_CACHE_PATH, LEGACY_GEMINI_SESSION_CACHE, null);
+  const cache = readJsonMigrate(
+    GEMINI_SESSION_CACHE_PATH,
+    LEGACY_GEMINI_SESSION_CACHE,
+    null,
+  );
   if (!cache?.session) {
     return { session: null, shouldRefresh: true };
   }
@@ -275,14 +369,33 @@ export function refreshGeminiSessionCache() {
 export function scheduleGeminiSessionRefresh() {
   const scriptPath = process.argv[1];
   if (!scriptPath) return;
+
+  // 스폰 락: 30초 내 이미 스폰했으면 중복 방지
   try {
-    const child = spawn(process.execPath, [scriptPath, GEMINI_SESSION_REFRESH_FLAG], {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true,
-    });
+    if (existsSync(GEMINI_SESSION_REFRESH_LOCK_PATH)) {
+      const lockAge =
+        Date.now() - readJson(GEMINI_SESSION_REFRESH_LOCK_PATH, {}).t;
+      if (lockAge < SPAWN_LOCK_TTL_MS) return;
+    }
+    writeJsonSafe(GEMINI_SESSION_REFRESH_LOCK_PATH, { t: Date.now() });
+  } catch {
+    /* 락 실패 무시 — 스폰 진행 */
+  }
+
+  try {
+    const child = spawn(
+      process.execPath,
+      [scriptPath, GEMINI_SESSION_REFRESH_FLAG],
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+      },
+    );
     child.unref();
-  } catch { /* 백그라운드 실행 실패 무시 */ }
+  } catch {
+    /* 백그라운드 실행 실패 무시 */
+  }
 }
 
 // ============================================================================
@@ -294,27 +407,47 @@ export function scanGeminiSessionTokens() {
   let best = null;
   let bestTime = 0;
   try {
-    const dirs = readdirSync(tmpDir).filter((d) => existsSync(join(tmpDir, d, "chats")));
+    const dirs = readdirSync(tmpDir).filter((d) =>
+      existsSync(join(tmpDir, d, "chats")),
+    );
     for (const dir of dirs) {
       const chatsDir = join(tmpDir, dir, "chats");
       let files;
-      try { files = readdirSync(chatsDir).filter((f) => f.endsWith(".json")); } catch { continue; }
+      try {
+        files = readdirSync(chatsDir).filter((f) => f.endsWith(".json"));
+      } catch {
+        continue;
+      }
       for (const file of files) {
         try {
           const data = JSON.parse(readFileSync(join(chatsDir, file), "utf-8"));
           const updatedAt = new Date(data.lastUpdated || 0).getTime();
           if (updatedAt <= bestTime) continue;
-          let input = 0, output = 0;
+          let input = 0,
+            output = 0;
           let model = "unknown";
           for (const msg of data.messages || []) {
-            if (msg.tokens) { input += msg.tokens.input || 0; output += msg.tokens.output || 0; }
+            if (msg.tokens) {
+              input += msg.tokens.input || 0;
+              output += msg.tokens.output || 0;
+            }
             if (msg.model) model = msg.model;
           }
           bestTime = updatedAt;
-          best = { input, output, total: input + output, model, lastUpdated: data.lastUpdated };
-        } catch { /* 무시 */ }
+          best = {
+            input,
+            output,
+            total: input + output,
+            model,
+            lastUpdated: data.lastUpdated,
+          };
+        } catch {
+          /* 무시 */
+        }
       }
     }
-  } catch { /* 무시 */ }
+  } catch {
+    /* 무시 */
+  }
   return best;
 }