@triflux/core 10.42.0 → 10.44.0

package/hud/providers/codex.mjs

@@ -8,7 +8,11 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import {
   CODEX_AUTH_PATH,
+  CODEX_BROKER_AUTH_CACHE_DIR,
   CODEX_MIN_BUCKETS,
+  CODEX_PROBE_STATE_PATH,
+  CODEX_PROBE_TIMEOUT_MS,
+  CODEX_PROBE_TTL_MS,
   CODEX_QUOTA_CACHE_PATH,
   CODEX_QUOTA_STALE_MS,
   CODEX_REFRESH_FLAG,
@@ -16,6 +20,11 @@ import {
   SPAWN_LOCK_TTL_MS,
 } from "../constants.mjs";
 import { decodeJwtEmail, readJson, writeJsonSafe } from "../utils.mjs";
+import {
+  listProbeTargets,
+  probeRateLimitsViaAppServer,
+  recordProbe,
+} from "./codex-probe.mjs";
 
 // window_minutes 기반 5h/1w 슬롯 분류
 // 5h: ≤360min (300min 표준, ±20% 허용)
@@ -50,9 +59,11 @@ export function getCodexEmail() {
 }
 
 // resets_at이 지난 윈도우의 used_percent를 0으로 보정
-export function expireStaleCodexBuckets(buckets) {
+export function expireStaleCodexBuckets(
+  buckets,
+  nowSec = Math.floor(Date.now() / 1000),
+) {
   if (!buckets) return buckets;
-  const nowSec = Math.floor(Date.now() / 1000);
   const result = {};
   for (const [key, bucket] of Object.entries(buckets)) {
     if (!bucket) {
@@ -63,13 +74,13 @@ export function expireStaleCodexBuckets(buckets) {
     if (bucket.primary?.resets_at && bucket.primary.resets_at <= nowSec) {
       updated = {
         ...updated,
-        primary: { ...updated.primary, used_percent: 0 },
+        primary: { ...updated.primary, used_percent: 0, expired: true },
       };
     }
     if (bucket.secondary?.resets_at && bucket.secondary.resets_at <= nowSec) {
       updated = {
         ...updated,
-        secondary: { ...updated.secondary, used_percent: 0 },
+        secondary: { ...updated.secondary, used_percent: 0, expired: true },
       };
     }
     result[key] = updated;
@@ -77,51 +88,178 @@ export function expireStaleCodexBuckets(buckets) {
   return result;
 }
 
+const RESET_CLUSTER_TOLERANCE_SEC = 90;
+
+function isNewerSnapshot(candidate, current) {
+  if (!current) return true;
+  const candidateTimestamp = Date.parse(candidate.timestamp);
+  const currentTimestamp = Date.parse(current.timestamp);
+  return (
+    Number.isFinite(candidateTimestamp) &&
+    (!Number.isFinite(currentTimestamp) ||
+      candidateTimestamp > currentTimestamp)
+  );
+}
+
+function selectCodexWindowSnapshot(snapshots, nowSec, windowKey) {
+  const groups = [];
+  const ungrouped = [];
+
+  for (const snapshot of snapshots) {
+    const resetAt = Number(snapshot[windowKey]?.resets_at);
+    if (!Number.isFinite(resetAt)) {
+      ungrouped.push(snapshot);
+      continue;
+    }
+
+    let group = groups.find(
+      (candidate) =>
+        Math.max(candidate.maxResetAt, resetAt) -
+          Math.min(candidate.minResetAt, resetAt) <=
+        RESET_CLUSTER_TOLERANCE_SEC,
+    );
+    if (!group) {
+      group = {
+        minResetAt: resetAt,
+        maxResetAt: resetAt,
+        latest: snapshot,
+      };
+      groups.push(group);
+      continue;
+    }
+
+    group.minResetAt = Math.min(group.minResetAt, resetAt);
+    group.maxResetAt = Math.max(group.maxResetAt, resetAt);
+    if (isNewerSnapshot(snapshot, group.latest)) group.latest = snapshot;
+  }
+
+  const activeGroups = groups.filter(
+    (group) => Number(group.latest[windowKey]?.resets_at) > nowSec,
+  );
+  let selected = null;
+  if (activeGroups.length > 0) {
+    selected = activeGroups
+      .map((group) => group.latest)
+      .sort((a, b) => {
+        const usedDifference =
+          Number(b[windowKey]?.used_percent || 0) -
+          Number(a[windowKey]?.used_percent || 0);
+        if (usedDifference !== 0) return usedDifference;
+        return Date.parse(b.timestamp) - Date.parse(a.timestamp);
+      })[0];
+  } else {
+    for (const snapshot of [
+      ...groups.map((group) => group.latest),
+      ...ungrouped,
+    ]) {
+      if (isNewerSnapshot(snapshot, selected)) selected = snapshot;
+    }
+  }
+
+  return { snapshot: selected, activeGroupCount: activeGroups.length };
+}
+
+function selectCodexSnapshot(snapshots, nowSec) {
+  const primarySelection = selectCodexWindowSnapshot(
+    snapshots,
+    nowSec,
+    "primary",
+  );
+  const secondarySelection = selectCodexWindowSnapshot(
+    snapshots,
+    nowSec,
+    "secondary",
+  );
+  const primarySnapshot = primarySelection.snapshot;
+  if (!primarySnapshot) return null;
+
+  const secondarySnapshot = secondarySelection.snapshot;
+  const selected = {
+    ...primarySnapshot,
+    secondary: secondarySnapshot?.secondary || null,
+    secondaryTimestamp:
+      secondarySnapshot?.timestamp || primarySnapshot.timestamp,
+  };
+  if (
+    primarySelection.activeGroupCount >= 2 ||
+    secondarySelection.activeGroupCount >= 2
+  ) {
+    selected.mixedWindows = true;
+  }
+  return selected;
+}
+
+function mergeRateLimitSnapshots(snapshots, nowSec) {
+  const merged = {};
+  const codexSnapshots = [];
+  for (const snapshot of snapshots) {
+    if (snapshot.limitId === "codex") {
+      codexSnapshots.push(snapshot);
+      continue;
+    }
+    if (isNewerSnapshot(snapshot, merged[snapshot.limitId])) {
+      merged[snapshot.limitId] = snapshot;
+    }
+  }
+
+  const codex = selectCodexSnapshot(codexSnapshots, nowSec);
+  if (codex) merged.codex = codex;
+  return merged;
+}
+
 // ============================================================================
 // Codex 세션 JSONL에서 실제 rate limits 추출
 // 한계: rate_limits는 세션별 스냅샷이므로 여러 세션 간 토큰 합산은 불가.
 // 최근 7일간 세션 파일을 스캔해 가장 최신 rate_limits 버킷을 수집한다.
 // 합성 버킷(token_count 기반)은 2일 이내 데이터만 허용하여 stale 방지.
 // ============================================================================
-export function getCodexRateLimits() {
-  const now = new Date();
+export function getCodexRateLimits({
+  sessionsRoot = join(homedir(), ".codex", "sessions"),
+  now = new Date(),
+  maxLinesPerFile = 800,
+  extraSnapshots = [],
+} = {}) {
   let syntheticBucket = null; // 최근 token_count에서 합성 (행 활성화 + 토큰 데이터용)
+  const recentSnapshots = [...extraSnapshots];
+  const nowSec = Math.floor(now.getTime() / 1000);
 
   // 7일간 스캔: 실제 rate_limits 우선, 합성 버킷은 폴백
   for (let dayOffset = 0; dayOffset <= 6; dayOffset++) {
     const d = new Date(now.getTime() - dayOffset * 86_400_000);
     const sessDir = join(
-      homedir(),
-      ".codex",
-      "sessions",
+      sessionsRoot,
       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;
+    let files = [];
+    if (existsSync(sessDir)) {
+      try {
+        files = readdirSync(sessDir)
+          .filter((f) => f.endsWith(".jsonl"))
+          .sort()
+          .reverse();
+      } catch {
+        files = [];
+      }
     }
 
-    const mergedBuckets = {};
+    const daySnapshots = [];
     for (const file of files) {
       try {
         const content = readFileSync(join(sessDir, file), "utf-8");
+        const found = {};
         const lines = content.trim().split("\n").reverse();
+        let scanned = 0;
         for (const line of lines) {
+          if (++scanned > maxLinesPerFile) break;
           try {
             const evt = JSON.parse(line);
             const rl = evt?.payload?.rate_limits;
-            if (rl?.limit_id && !mergedBuckets[rl.limit_id]) {
+            if (rl?.limit_id && !found[rl.limit_id]) {
               // window_minutes 기준으로 5h/1w 슬롯 정규화
               const { primary, secondary } = normalizeBuckets(rl);
-              mergedBuckets[rl.limit_id] = {
+              found[rl.limit_id] = {
                 limitId: rl.limit_id,
                 limitName: rl.limit_name,
                 primary,
@@ -152,21 +290,28 @@ export function getCodexRateLimits() {
           } catch {
             /* 라인 파싱 실패 무시 */
           }
-          if (Object.keys(mergedBuckets).length >= CODEX_MIN_BUCKETS) break;
+          if (Object.keys(found).length >= CODEX_MIN_BUCKETS) break;
         }
+        daySnapshots.push(...Object.values(found));
       } catch {
         /* 파일 읽기 실패 무시 */
       }
     }
-    // 실제 rate_limits 발견 → 토큰 데이터 병합 후 즉시 반환
+
+    if (dayOffset <= 1) {
+      recentSnapshots.push(...daySnapshots);
+      if (dayOffset === 0) continue;
+    }
+
+    const snapshots = dayOffset <= 1 ? recentSnapshots : daySnapshots;
+    const mergedBuckets = mergeRateLimitSnapshots(snapshots, nowSec);
     if (Object.keys(mergedBuckets).length > 0) {
       if (syntheticBucket) {
         const main =
           mergedBuckets.codex || mergedBuckets[Object.keys(mergedBuckets)[0]];
         if (main && !main.tokens) main.tokens = syntheticBucket.tokens;
       }
-      expireStaleCodexBuckets(mergedBuckets);
-      return mergedBuckets;
+      return expireStaleCodexBuckets(mergedBuckets, nowSec);
     }
   }
   // 실제 rate_limits 없음 → 합성 버킷이라도 반환 (행 활성화)
@@ -178,15 +323,47 @@ export function readCodexRateLimitSnapshot() {
   if (!cache?.buckets) {
     return { buckets: null, shouldRefresh: true };
   }
-  expireStaleCodexBuckets(cache.buckets);
+  const buckets = expireStaleCodexBuckets(cache.buckets);
   const ts = Number(cache.timestamp);
   const ageMs = Number.isFinite(ts) ? Date.now() - ts : Number.MAX_SAFE_INTEGER;
   const isFresh = ageMs < CODEX_QUOTA_STALE_MS;
-  return { buckets: cache.buckets, shouldRefresh: !isFresh };
+  return { buckets, shouldRefresh: !isFresh };
 }
 
-export function refreshCodexRateLimitsCache() {
-  const buckets = getCodexRateLimits();
+export async function collectProbeSnapshots(now = new Date()) {
+  if (process.env.TFX_CODEX_PROBE === "0") return [];
+  let targets = [];
+  try {
+    targets = listProbeTargets({
+      codexAuthPath: CODEX_AUTH_PATH,
+      brokerCacheDir: CODEX_BROKER_AUTH_CACHE_DIR,
+      stateFilePath: CODEX_PROBE_STATE_PATH,
+      ttlMs: Number(process.env.TFX_CODEX_PROBE_TTL_MS) || CODEX_PROBE_TTL_MS,
+      nowMs: now.getTime(),
+    });
+  } catch {
+    return [];
+  }
+  const settled = await Promise.allSettled(
+    targets.map(async (target) => {
+      const snapshots = await probeRateLimitsViaAppServer({
+        codexHome: target.codexHome,
+        timeoutMs: CODEX_PROBE_TIMEOUT_MS,
+        now,
+      });
+      recordProbe(CODEX_PROBE_STATE_PATH, target.key, now.getTime());
+      return snapshots || [];
+    }),
+  );
+  return settled.flatMap((result) =>
+    result.status === "fulfilled" ? result.value : [],
+  );
+}
+
+export async function refreshCodexRateLimitsCache() {
+  const now = new Date();
+  const extraSnapshots = await collectProbeSnapshots(now);
+  const buckets = getCodexRateLimits({ now, extraSnapshots });
   // buckets가 null이어도 캐시 갱신 (stale 데이터 제거)
   writeJsonSafe(CODEX_QUOTA_CACHE_PATH, { timestamp: Date.now(), buckets });
   return buckets;

package/hud/renderers.mjs

@@ -680,13 +680,11 @@ export function getProviderRow(
             ? colorByProvider(weekP, formatPercentCell(weekP), provFn)
             : dim(formatPlaceholderPercentCell());
         const fiveReset =
-          formatResetRemaining(main.primary?.resets_at, FIVE_HOUR_MS) || "n/a";
+          formatResetRemaining(main.primary?.resets_at) || "n/a";
         const weekReset =
-          formatResetRemainingDayHour(
-            main.secondary?.resets_at,
-            SEVEN_DAY_MS,
-          ) || "n/a";
+          formatResetRemainingDayHour(main.secondary?.resets_at) || "n/a";
         quotaSection = `${dim("5h:")}${fCell} ${dim(formatTimeCell(fiveReset))} ${dim("1w:")}${wCell} ${dim(formatTimeCellDH(weekReset))}`;
+        if (main.mixedWindows) quotaSection += dim("*");
       }
     }
     if (provider === "gemini" && realQuota?.type === "gemini") {
@@ -742,11 +740,9 @@ export function getProviderRow(
         main.secondary?.used_percent != null
           ? clampPercent(main.secondary.used_percent)
           : null;
-      const fiveReset =
-        formatResetRemaining(main.primary?.resets_at, FIVE_HOUR_MS) || "n/a";
+      const fiveReset = formatResetRemaining(main.primary?.resets_at) || "n/a";
       const weekReset =
-        formatResetRemainingDayHour(main.secondary?.resets_at, SEVEN_DAY_MS) ||
-        "n/a";
+        formatResetRemainingDayHour(main.secondary?.resets_at) || "n/a";
       const fCell =
         fiveP != null
           ? colorByProvider(fiveP, formatPercentCell(fiveP), provFn)
@@ -768,6 +764,7 @@ export function getProviderRow(
         `${dim(formatTimeCell(fiveReset))} ` +
         `${dim("1w:")}${wBar}${wCell} ` +
         `${dim(formatTimeCellDH(weekReset))}`;
+      if (main.mixedWindows) quotaSection += dim("*");
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/core",
-  "version": "10.42.0",
+  "version": "10.44.0",
   "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",