@triflux/core 10.42.0 → 10.43.0

package/hud/providers/codex-probe.mjs

@@ -0,0 +1,216 @@
+// codex app-server account/rateLimits/read 능동 프로브 + 정규화.
+// 세션 이벤트(snake_case) 파이프라인에 합류 가능한 스냅샷을 만든다.
+
+import { spawn } from "node:child_process";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+function readJwtExpSec(token) {
+  try {
+    const payload = JSON.parse(
+      Buffer.from(token.split(".")[1], "base64url").toString("utf-8"),
+    );
+    return Number(payload.exp) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+const EXP_MARGIN_SEC = 600;
+
+function accessTokenUsable(auth, nowMs) {
+  const token = auth?.tokens?.access_token;
+  if (!token) return false;
+  const exp = readJwtExpSec(token);
+  return exp > Math.floor(nowMs / 1000) + EXP_MARGIN_SEC;
+}
+
+export function recordProbe(stateFilePath, key, nowMs) {
+  const state = readJsonFile(stateFilePath) || {};
+  state[key] = nowMs;
+  try {
+    mkdirSync(dirname(stateFilePath), { recursive: true });
+    writeFileSync(stateFilePath, JSON.stringify(state));
+  } catch {
+    // 상태 기록 실패는 무시 — 다음 사이클에 재시도
+  }
+}
+
+export function listProbeTargets({
+  codexAuthPath,
+  brokerCacheDir,
+  stateFilePath,
+  ttlMs,
+  nowMs,
+}) {
+  const state = readJsonFile(stateFilePath) || {};
+  const due = (key) =>
+    !(Number(state[key]) > 0 && nowMs - Number(state[key]) < ttlMs);
+  const targets = [];
+
+  const currentAuth = readJsonFile(codexAuthPath);
+  if (currentAuth && accessTokenUsable(currentAuth, nowMs) && due("current")) {
+    targets.push({ key: "current", codexHome: dirname(codexAuthPath) });
+  }
+
+  if (brokerCacheDir && existsSync(brokerCacheDir)) {
+    let files = [];
+    try {
+      files = readdirSync(brokerCacheDir).filter((file) =>
+        /^codex-auth-.+\.json$/.test(file),
+      );
+    } catch {
+      files = [];
+    }
+    for (const file of files) {
+      const key = file.replace(/^codex-auth-/, "").replace(/\.json$/, "");
+      if (!due(key)) continue;
+      const auth = readJsonFile(join(brokerCacheDir, file));
+      if (!auth || !accessTokenUsable(auth, nowMs)) continue;
+      const home = mkdtempSync(join(tmpdir(), `tfx-probe-home-${key}-`));
+      writeFileSync(join(home, "auth.json"), JSON.stringify(auth));
+      targets.push({ key, codexHome: home });
+    }
+  }
+  return targets;
+}
+
+function toSnakeBucket(bucket) {
+  if (!bucket) return null;
+  return {
+    used_percent: bucket.usedPercent ?? null,
+    window_minutes: bucket.windowDurationMins ?? null,
+    resets_at: bucket.resetsAt ?? null,
+  };
+}
+
+function toSnapshot(entry, nowIso) {
+  return {
+    limitId: entry.limitId,
+    limitName: entry.limitName ?? null,
+    primary: toSnakeBucket(entry.primary),
+    secondary: toSnakeBucket(entry.secondary),
+    credits: entry.credits ?? null,
+    tokens: null,
+    contextWindow: null,
+    timestamp: nowIso,
+    probe: true,
+  };
+}
+
+export function normalizeAppServerRateLimits(result, nowIso) {
+  if (!result) return [];
+  const byId = result.rateLimitsByLimitId;
+  if (byId && typeof byId === "object" && Object.keys(byId).length > 0) {
+    return Object.values(byId)
+      .filter((e) => e?.limitId)
+      .map((e) => toSnapshot(e, nowIso));
+  }
+  if (result.rateLimits?.limitId) {
+    return [toSnapshot(result.rateLimits, nowIso)];
+  }
+  return [];
+}
+
+export function probeRateLimitsViaAppServer({
+  codexHome = null,
+  spawnBin = "codex",
+  spawnArgs = ["app-server"],
+  timeoutMs = 10000,
+  now = new Date(),
+} = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(spawnBin, spawnArgs, {
+        stdio: ["pipe", "pipe", "ignore"],
+        env: codexHome
+          ? { ...process.env, CODEX_HOME: codexHome }
+          : process.env,
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+    let settled = false;
+    let buf = "";
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child.kill();
+      } catch {
+        // 이미 종료
+      }
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    const send = (obj) => {
+      try {
+        child.stdin.write(`${JSON.stringify(obj)}\n`);
+      } catch {
+        finish(null);
+      }
+    };
+    child.on("error", () => finish(null));
+    child.on("exit", () => finish(null));
+    child.stdout.on("data", (data) => {
+      buf += data.toString();
+      let idx = buf.indexOf("\n");
+      while (idx >= 0) {
+        const line = buf.slice(0, idx);
+        buf = buf.slice(idx + 1);
+        idx = buf.indexOf("\n");
+        if (!line.trim()) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (msg.id === 1 && msg.result) {
+          send({
+            jsonrpc: "2.0",
+            id: 2,
+            method: "account/rateLimits/read",
+            params: {},
+          });
+        } else if (msg.id === 2) {
+          if (msg.error) finish(null);
+          else {
+            finish(normalizeAppServerRateLimits(msg.result, now.toISOString()));
+          }
+        }
+      }
+    });
+    send({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        clientInfo: {
+          name: "triflux-hud-probe",
+          title: "triflux HUD quota probe",
+          version: "1.0.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.43.0",
   "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/cli-agy.mjs

@@ -5,6 +5,7 @@
 //
 // 출처: scripts/tfx-route.sh route_agent() L1052-L1059, run_codex_exec() L2036-L2046.
 //        .claude/rules/tfx-update-logic.md Antigravity CLI 1.0.0 정밀 sanity matrix.
+// timeoutSec은 lane 예상 소요 시간(advisory)이다. hard ceiling 집행은 Bash route가 소유한다.
 
 export const id = "agy";
 export const cliType = "antigravity";

package/scripts/lib/cli-claude.mjs

@@ -5,6 +5,7 @@
 //
 // 출처: scripts/tfx-route.sh route_agent() L1062-L1063 (explore|claude),
 //        L1196-L1203 (TFX_CLI_MODE=gemini fallback), TFX_VERIFIER_OVERRIDE=claude.
+// timeoutSec은 lane 예상 소요 시간(advisory)이다. hard ceiling 집행은 Bash route가 소유한다.
 
 export const id = "claude";
 export const cliType = "claude-native";