triflux 10.3.4 → 10.7.0

package/hud/providers/claude.mjs

@@ -1,20 +1,33 @@
 // ============================================================================
 // Claude Usage API (api.anthropic.com/api/oauth/usage)
 // ============================================================================
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import https from "node:https";
+
 import { spawn } from "node:child_process";
+import { existsSync, writeFileSync } from "node:fs";
+import https from "node:https";
 import {
-  CLAUDE_CREDENTIALS_PATH, CLAUDE_USAGE_CACHE_PATH, OMC_PLUGIN_USAGE_CACHE_PATH,
-  CLAUDE_USAGE_STALE_MS_SOLO, CLAUDE_USAGE_STALE_MS_WITH_OMC,
-  CLAUDE_USAGE_429_BACKOFF_MS, CLAUDE_USAGE_ERROR_BACKOFF_MS,
-  CLAUDE_API_TIMEOUT_MS, FIVE_HOUR_MS, SEVEN_DAY_MS,
-  DEFAULT_OAUTH_CLIENT_ID, CLAUDE_REFRESH_FLAG,
+  CLAUDE_API_TIMEOUT_MS,
+  CLAUDE_CREDENTIALS_PATH,
+  CLAUDE_REFRESH_FLAG,
+  CLAUDE_REFRESH_LOCK_PATH,
+  CLAUDE_USAGE_429_BACKOFF_MS,
+  CLAUDE_USAGE_CACHE_PATH,
+  CLAUDE_USAGE_ERROR_BACKOFF_MS,
+  CLAUDE_USAGE_STALE_MS_SOLO,
+  CLAUDE_USAGE_STALE_MS_WITH_OMC,
+  DEFAULT_OAUTH_CLIENT_ID,
+  FIVE_HOUR_MS,
+  OMC_PLUGIN_USAGE_CACHE_PATH,
+  SEVEN_DAY_MS,
+  SPAWN_LOCK_TTL_MS,
 } from "../constants.mjs";
-import { readJson, writeJsonSafe, clampPercent, advanceToNextCycle } from "../utils.mjs";
 import { readContextMonitorSnapshot } from "../context-monitor.mjs";
+import {
+  advanceToNextCycle,
+  clampPercent,
+  readJson,
+  writeJsonSafe,
+} from "../utils.mjs";
 
 export const CLAUDE_USAGE_POLL_BASE_MS = 5_000;
 export const CLAUDE_USAGE_POLL_JITTER_RATIO = 0.2;
@@ -39,15 +52,20 @@ export function computeClaudeUsagePollState({
   random = Math.random,
   jitterRatio = CLAUDE_USAGE_POLL_JITTER_RATIO,
 } = {}) {
-  const current429s = Number.isFinite(consecutive429s) ? Math.max(0, consecutive429s) : 0;
-  const next429s = outcome === "rate_limit" ? current429s + 1 : 0;
-  const stepIndex = outcome === "rate_limit"
-    ? Math.min(next429s, CLAUDE_USAGE_RATE_LIMIT_BACKOFF_MS.length - 1)
+  const current429s = Number.isFinite(consecutive429s)
+    ? Math.max(0, consecutive429s)
     : 0;
+  const next429s = outcome === "rate_limit" ? current429s + 1 : 0;
+  const stepIndex =
+    outcome === "rate_limit"
+      ? Math.min(next429s, CLAUDE_USAGE_RATE_LIMIT_BACKOFF_MS.length - 1)
+      : 0;
   const baseDelayMs = CLAUDE_USAGE_RATE_LIMIT_BACKOFF_MS[stepIndex];
   const sample = Number(random?.());
-  const normalized = Number.isFinite(sample) ? Math.min(1, Math.max(0, sample)) : 0.5;
-  const jitterFactor = 1 + ((normalized * 2) - 1) * jitterRatio;
+  const normalized = Number.isFinite(sample)
+    ? Math.min(1, Math.max(0, sample))
+    : 0.5;
+  const jitterFactor = 1 + (normalized * 2 - 1) * jitterRatio;
   return {
     consecutive429s: next429s,
     baseDelayMs,
@@ -65,9 +83,13 @@ function getSnapshotSchedule(cache) {
     };
   }
 
-  const ageMs = Number.isFinite(timestamp) ? Date.now() - timestamp : Number.MAX_SAFE_INTEGER;
+  const ageMs = Number.isFinite(timestamp)
+    ? Date.now() - timestamp
+    : Number.MAX_SAFE_INTEGER;
   const fallbackMs = cache?.error
-    ? (cache.errorType === "rate_limit" ? CLAUDE_USAGE_429_BACKOFF_MS : CLAUDE_USAGE_ERROR_BACKOFF_MS)
+    ? cache.errorType === "rate_limit"
+      ? CLAUDE_USAGE_429_BACKOFF_MS
+      : CLAUDE_USAGE_ERROR_BACKOFF_MS
     : getClaudeUsageStaleMs();
 
   return {
@@ -90,45 +112,56 @@ export function readClaudeCredentials() {
 
 export function refreshClaudeAccessToken(refreshToken) {
   return new Promise((resolve) => {
-    const clientId = process.env.CLAUDE_CODE_OAUTH_CLIENT_ID || DEFAULT_OAUTH_CLIENT_ID;
+    const clientId =
+      process.env.CLAUDE_CODE_OAUTH_CLIENT_ID || DEFAULT_OAUTH_CLIENT_ID;
     const body = new URLSearchParams({
       grant_type: "refresh_token",
       refresh_token: refreshToken,
       client_id: clientId,
     }).toString();
-    const req = https.request({
-      hostname: "platform.claude.com",
-      path: "/v1/oauth/token",
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Content-Length": Buffer.byteLength(body),
+    const req = https.request(
+      {
+        hostname: "platform.claude.com",
+        path: "/v1/oauth/token",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Content-Length": Buffer.byteLength(body),
+        },
+        timeout: CLAUDE_API_TIMEOUT_MS,
       },
-      timeout: CLAUDE_API_TIMEOUT_MS,
-    }, (res) => {
-      let data = "";
-      res.on("data", (chunk) => { data += chunk; });
-      res.on("end", () => {
-        if (res.statusCode === 200) {
-          try {
-            const parsed = JSON.parse(data);
-            if (parsed.access_token) {
-              resolve({
-                accessToken: parsed.access_token,
-                refreshToken: parsed.refresh_token || refreshToken,
-                expiresAt: parsed.expires_in
-                  ? Date.now() + parsed.expires_in * 1000
-                  : parsed.expires_at,
-              });
-              return;
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed.access_token) {
+                resolve({
+                  accessToken: parsed.access_token,
+                  refreshToken: parsed.refresh_token || refreshToken,
+                  expiresAt: parsed.expires_in
+                    ? Date.now() + parsed.expires_in * 1000
+                    : parsed.expires_at,
+                });
+                return;
+              }
+            } catch {
+              /* parse 실패 */
             }
-          } catch { /* parse 실패 */ }
-        }
-        resolve(null);
-      });
-    });
+          }
+          resolve(null);
+        });
+      },
+    );
     req.on("error", () => resolve(null));
-    req.on("timeout", () => { req.destroy(); resolve(null); });
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
     req.end(body);
   });
 }
@@ -142,34 +175,48 @@ export function writeBackClaudeCredentials(creds) {
     if (creds.expiresAt != null) target.expiresAt = creds.expiresAt;
     if (creds.refreshToken) target.refreshToken = creds.refreshToken;
     writeFileSync(CLAUDE_CREDENTIALS_PATH, JSON.stringify(data, null, 2));
-  } catch { /* 쓰기 실패 무시 */ }
+  } catch {
+    /* 쓰기 실패 무시 */
+  }
 }
 
 export function fetchClaudeUsageFromApi(accessToken) {
   return new Promise((resolve) => {
-    const req = https.request({
-      hostname: "api.anthropic.com",
-      path: "/api/oauth/usage",
-      method: "GET",
-      headers: {
-        "Authorization": `Bearer ${accessToken}`,
-        "anthropic-beta": "oauth-2025-04-20",
-        "Content-Type": "application/json",
+    const req = https.request(
+      {
+        hostname: "api.anthropic.com",
+        path: "/api/oauth/usage",
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "anthropic-beta": "oauth-2025-04-20",
+          "Content-Type": "application/json",
+        },
+        timeout: CLAUDE_API_TIMEOUT_MS,
       },
-      timeout: CLAUDE_API_TIMEOUT_MS,
-    }, (res) => {
-      let data = "";
-      res.on("data", (chunk) => { data += chunk; });
-      res.on("end", () => {
-        if (res.statusCode === 200) {
-          try { resolve({ ok: true, data: JSON.parse(data) }); } catch { resolve({ ok: false, status: 0 }); }
-        } else {
-          resolve({ ok: false, status: res.statusCode });
-        }
-      });
-    });
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            try {
+              resolve({ ok: true, data: JSON.parse(data) });
+            } catch {
+              resolve({ ok: false, status: 0 });
+            }
+          } else {
+            resolve({ ok: false, status: res.statusCode });
+          }
+        });
+      },
+    );
     req.on("error", () => resolve({ ok: false, status: 0, error: "network" }));
-    req.on("timeout", () => { req.destroy(); resolve({ ok: false, status: 0, error: "timeout" }); });
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({ ok: false, status: 0, error: "timeout" });
+    });
     req.end();
   });
 }
@@ -195,11 +242,17 @@ export function stripStaleResets(data) {
   const copy = { ...data };
   if (copy.fiveHourResetsAt) {
     const t = new Date(copy.fiveHourResetsAt).getTime();
-    if (!isNaN(t)) copy.fiveHourResetsAt = new Date(advanceToNextCycle(t, FIVE_HOUR_MS)).toISOString();
+    if (!Number.isNaN(t))
+      copy.fiveHourResetsAt = new Date(
+        advanceToNextCycle(t, FIVE_HOUR_MS),
+      ).toISOString();
   }
   if (copy.weeklyResetsAt) {
     const t = new Date(copy.weeklyResetsAt).getTime();
-    if (!isNaN(t)) copy.weeklyResetsAt = new Date(advanceToNextCycle(t, SEVEN_DAY_MS)).toISOString();
+    if (!Number.isNaN(t))
+      copy.weeklyResetsAt = new Date(
+        advanceToNextCycle(t, SEVEN_DAY_MS),
+      ).toISOString();
   }
   return copy;
 }
@@ -208,9 +261,10 @@ export function readClaudeUsageSnapshot() {
   const cache = readJson(CLAUDE_USAGE_CACHE_PATH, null);
   const ts = Number(cache?.timestamp);
   const schedule = getSnapshotSchedule(cache);
-  const staleBackoffActive = cache?.errorType === "rate_limit"
-    && Number.isFinite(schedule.nextRefreshAt)
-    && Date.now() < schedule.nextRefreshAt;
+  const staleBackoffActive =
+    cache?.errorType === "rate_limit" &&
+    Number.isFinite(schedule.nextRefreshAt) &&
+    Date.now() < schedule.nextRefreshAt;
 
   // 1차: 자체 캐시에 유효 데이터가 있는 경우
   if (cache?.data) {
@@ -225,7 +279,10 @@ export function readClaudeUsageSnapshot() {
     // resets_at이 지난 윈도우의 percent를 0으로 보정 (stale 캐시 방지)
     const data = { ...cache.data };
     const now = Date.now();
-    if (data.fiveHourResetsAt && new Date(data.fiveHourResetsAt).getTime() <= now) {
+    if (
+      data.fiveHourResetsAt &&
+      new Date(data.fiveHourResetsAt).getTime() <= now
+    ) {
       data.fiveHourPercent = 0;
     }
     if (data.weeklyResetsAt && new Date(data.weeklyResetsAt).getTime() <= now) {
@@ -244,8 +301,15 @@ export function readClaudeUsageSnapshot() {
         return { data: omcCache.data, shouldRefresh: false, isStale: false };
       }
       // stale OMC fallback 또는 null (--% 플레이스홀더 표시, 가짜 0% 방지)
-      const staleData = omcCache?.data?.fiveHourPercent != null ? stripStaleResets(omcCache.data) : null;
-      return { data: staleData, shouldRefresh: false, isStale: staleBackoffActive };
+      const staleData =
+        omcCache?.data?.fiveHourPercent != null
+          ? stripStaleResets(omcCache.data)
+          : null;
+      return {
+        data: staleData,
+        shouldRefresh: false,
+        isStale: staleBackoffActive,
+      };
     }
   }
 
@@ -253,36 +317,54 @@ export function readClaudeUsageSnapshot() {
   const OMC_CACHE_MAX_AGE_MS = 30 * 60 * 1000;
   const omcCache = readJson(OMC_PLUGIN_USAGE_CACHE_PATH, null);
   if (omcCache?.data?.fiveHourPercent != null) {
-    const omcAge = Number.isFinite(omcCache.timestamp) ? Date.now() - omcCache.timestamp : Number.MAX_SAFE_INTEGER;
+    const omcAge = Number.isFinite(omcCache.timestamp)
+      ? Date.now() - omcCache.timestamp
+      : Number.MAX_SAFE_INTEGER;
     if (omcAge < OMC_CACHE_MAX_AGE_MS) {
       writeClaudeUsageCache(omcCache.data);
-      return { data: omcCache.data, shouldRefresh: omcAge > getClaudeUsageStaleMs(), isStale: false };
+      return {
+        data: omcCache.data,
+        shouldRefresh: omcAge > getClaudeUsageStaleMs(),
+        isStale: false,
+      };
     }
     // stale이어도 data: null보다는 오래된 데이터를 fallback으로 표시
-    return { data: stripStaleResets(omcCache.data), shouldRefresh: true, isStale: false };
+    return {
+      data: stripStaleResets(omcCache.data),
+      shouldRefresh: true,
+      isStale: false,
+    };
   }
 
   // 캐시/fallback 모두 없음: null 반환 → --% 플레이스홀더 + 리프레시 시도
   return { data: null, shouldRefresh: true, isStale: false };
 }
 
-export function writeClaudeUsageCache(data, errorInfo = null, pollState = null) {
-  const state = pollState || (errorInfo
-    ? {
-      consecutive429s: errorInfo.type === "rate_limit" ? 1 : 0,
-      baseDelayMs: errorInfo.type === "rate_limit"
-        ? CLAUDE_USAGE_429_BACKOFF_MS
-        : CLAUDE_USAGE_ERROR_BACKOFF_MS,
-      delayMs: errorInfo.type === "rate_limit"
-        ? CLAUDE_USAGE_429_BACKOFF_MS
-        : CLAUDE_USAGE_ERROR_BACKOFF_MS,
-    }
-    : computeClaudeUsagePollState({ outcome: "success" }));
+export function writeClaudeUsageCache(
+  data,
+  errorInfo = null,
+  pollState = null,
+) {
+  const state =
+    pollState ||
+    (errorInfo
+      ? {
+          consecutive429s: errorInfo.type === "rate_limit" ? 1 : 0,
+          baseDelayMs:
+            errorInfo.type === "rate_limit"
+              ? CLAUDE_USAGE_429_BACKOFF_MS
+              : CLAUDE_USAGE_ERROR_BACKOFF_MS,
+          delayMs:
+            errorInfo.type === "rate_limit"
+              ? CLAUDE_USAGE_429_BACKOFF_MS
+              : CLAUDE_USAGE_ERROR_BACKOFF_MS,
+        }
+      : computeClaudeUsagePollState({ outcome: "success" }));
   const entry = {
     timestamp: Date.now(),
     data,
     error: !!errorInfo,
-    errorType: errorInfo?.type || null,   // "rate_limit" | "auth" | "network" | "unknown"
+    errorType: errorInfo?.type || null, // "rate_limit" | "auth" | "network" | "unknown"
     errorStatus: errorInfo?.status || null, // HTTP 상태 코드
     consecutive429s: state.consecutive429s,
     nextRefreshBaseMs: state.baseDelayMs,
@@ -305,7 +387,9 @@ export async function fetchClaudeUsage(forceRefresh = false) {
     return existingSnapshot.data || null;
   }
   const cache = readJson(CLAUDE_USAGE_CACHE_PATH, null);
-  const consecutive429s = Number.isFinite(cache?.consecutive429s) ? cache.consecutive429s : 0;
+  const consecutive429s = Number.isFinite(cache?.consecutive429s)
+    ? cache.consecutive429s
+    : 0;
   let creds = readClaudeCredentials();
   if (!creds) {
     writeClaudeUsageCache(null, { type: "auth", status: 0 });
@@ -327,19 +411,37 @@ export async function fetchClaudeUsage(forceRefresh = false) {
   const result = await fetchClaudeUsageFromApi(creds.accessToken);
   if (!result.ok) {
     // 에러 유형별 분류하여 backoff 차등 적용
-    const errorType = result.status === 429 ? "rate_limit"
-      : result.status === 401 || result.status === 403 ? "auth"
-      : result.error === "timeout" || result.error === "network" ? "network"
-      : "unknown";
-    const pollState = errorType === "rate_limit"
-      ? computeClaudeUsagePollState({ consecutive429s, outcome: "rate_limit" })
-      : null;
-    writeClaudeUsageCache(existingSnapshot.data, { type: errorType, status: result.status }, pollState);
+    const errorType =
+      result.status === 429
+        ? "rate_limit"
+        : result.status === 401 || result.status === 403
+          ? "auth"
+          : result.error === "timeout" || result.error === "network"
+            ? "network"
+            : "unknown";
+    const pollState =
+      errorType === "rate_limit"
+        ? computeClaudeUsagePollState({
+            consecutive429s,
+            outcome: "rate_limit",
+          })
+        : null;
+    writeClaudeUsageCache(
+      existingSnapshot.data,
+      { type: errorType, status: result.status },
+      pollState,
+    );
     return existingSnapshot.data || null;
   }
   const usage = parseClaudeUsageResponse(result.data);
-  const pollState = usage ? computeClaudeUsagePollState({ outcome: "success" }) : null;
-  writeClaudeUsageCache(usage, usage ? null : { type: "unknown", status: 0 }, pollState);
+  const pollState = usage
+    ? computeClaudeUsagePollState({ outcome: "success" })
+    : null;
+  writeClaudeUsageCache(
+    usage,
+    usage ? null : { type: "unknown", status: 0 },
+    pollState,
+  );
   return usage;
 }
 
@@ -351,23 +453,28 @@ export function scheduleClaudeUsageRefresh() {
   try {
     const omcCache = readJson(OMC_PLUGIN_USAGE_CACHE_PATH, null);
     if (omcCache?.data?.fiveHourPercent != null) {
-      const omcAge = Number.isFinite(omcCache.timestamp) ? Date.now() - omcCache.timestamp : Infinity;
+      const omcAge = Number.isFinite(omcCache.timestamp)
+        ? Date.now() - omcCache.timestamp
+        : Infinity;
       if (omcAge < getClaudeUsageStaleMs()) {
         writeClaudeUsageCache(omcCache.data); // HUD 캐시에 복사만
         return;
       }
     }
-  } catch { /* 무시 */ }
+  } catch {
+    /* 무시 */
+  }
 
   // 스폰 락: 30초 내 이미 스폰했으면 중복 방지 (첫 설치 시 429 방지)
-  const lockPath = join(homedir(), ".claude", "cache", ".claude-refresh-lock");
   try {
-    if (existsSync(lockPath)) {
-      const lockAge = Date.now() - readJson(lockPath, {}).t;
-      if (lockAge < 1000) return; // 짧은 중복 스폰만 억제, 실제 폴링 주기는 nextRefreshAt가 제어
+    if (existsSync(CLAUDE_REFRESH_LOCK_PATH)) {
+      const lockAge = Date.now() - readJson(CLAUDE_REFRESH_LOCK_PATH, {}).t;
+      if (lockAge < SPAWN_LOCK_TTL_MS) return;
     }
-    writeJsonSafe(lockPath, { t: Date.now() });
-  } catch { /* 락 실패 무시 — 스폰 진행 */ }
+    writeJsonSafe(CLAUDE_REFRESH_LOCK_PATH, { t: Date.now() });
+  } catch {
+    /* 락 실패 무시 — 스폰 진행 */
+  }
 
   try {
     const child = spawn(process.execPath, [scriptPath, CLAUDE_REFRESH_FLAG], {
@@ -378,7 +485,11 @@ export function scheduleClaudeUsageRefresh() {
     child.unref();
   } catch (spawnErr) {
     // spawn 실패 시 에러 유형을 캐시에 기록 (HUD에서 원인 힌트 표시 가능)
-    writeClaudeUsageCache(null, { type: "network", status: 0, hint: String(spawnErr?.message || spawnErr) });
+    writeClaudeUsageCache(null, {
+      type: "network",
+      status: 0,
+      hint: String(spawnErr?.message || spawnErr),
+    });
   }
 }
 

package/hud/providers/codex.mjs

@@ -1,16 +1,21 @@
 // ============================================================================
 // 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_REFRESH_LOCK_PATH, SPAWN_LOCK_TTL_MS,
+  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 슬롯 분류
 export function classifyBucket(bucket) {
@@ -37,7 +42,9 @@ 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으로 보정
@@ -46,13 +53,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;
   }
@@ -73,15 +89,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) {
@@ -96,33 +120,47 @@ export function getCodexRateLimits() {
               // window_minutes 기준으로 5h/1w 슬롯 정규화
               const { primary, secondary } = normalizeBuckets(rl);
               mergedBuckets[rl.limit_id] = {
-                limitId: rl.limit_id, limitName: rl.limit_name,
-                primary, 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);
@@ -163,7 +201,9 @@ export function scheduleCodexRateLimitRefresh() {
       if (lockAge < SPAWN_LOCK_TTL_MS) return;
     }
     writeJsonSafe(CODEX_REFRESH_LOCK_PATH, { t: Date.now() });
-  } catch { /* 락 실패 무시 — 스폰 진행 */ }
+  } catch {
+    /* 락 실패 무시 — 스폰 진행 */
+  }
 
   try {
     const child = spawn(process.execPath, [scriptPath, CODEX_REFRESH_FLAG], {