@triflux/core 10.53.0 → 10.55.0

package/hud/providers/codex.mjs

@@ -3,7 +3,15 @@
 // ============================================================================
 
 import { spawn } from "node:child_process";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import {
+  closeSync,
+  existsSync,
+  fstatSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  readSync,
+} from "node:fs";
 import { join } from "node:path";
 import {
   CODEX_MIN_BUCKETS,
@@ -253,6 +261,110 @@ function mergeRateLimitSnapshots(snapshots, nowSec) {
   return merged;
 }
 
+const EXTRA_BYTES_AFTER_FIRST_BUCKET = 64 * 1024;
+const REVERSE_READ_CHUNK_BYTES = 64 * 1024;
+
+// 파일 끝에서 줄 단위로 거슬러 읽는다. 호출자가 멈추는 지점까지만 디스크를 읽는다.
+// 0x0A 로만 나누므로 멀티바이트 UTF-8 이 청크 경계에서 깨지지 않는다.
+// 파일 양끝의 공백은 문자열 trim() 과 같게 버리고 중간의 빈 줄은 유지해,
+// 옛 content.trim().split("\n").reverse() 와 같은 줄을 낸다.
+export function createReverseLineReader(
+  path,
+  chunkBytes = REVERSE_READ_CHUNK_BYTES,
+) {
+  const fd = openSync(path, "r");
+  let pos;
+  try {
+    pos = fstatSync(fd).size;
+  } catch (err) {
+    closeSync(fd);
+    throw err;
+  }
+  let carryParts = []; // 아직 줄 시작을 못 만난 뒷부분 조각. 나중에 읽은(앞쪽) 조각이 뒤에 쌓인다
+  let queue = [];
+  let leadingBlank = -1; // 파일 맨 앞의 빈 줄 수. 끝까지 읽은 뒤에만 정해진다
+  let trimmingTail = true;
+  let yielded = false;
+  let emptyGiven = false;
+
+  function fill() {
+    const size = Math.min(chunkBytes, pos);
+    const chunk = Buffer.alloc(size);
+    pos -= size;
+    readSync(fd, chunk, 0, size, pos);
+    reader.bytesRead += size;
+    const pieces = [];
+    let start = 0;
+    for (
+      let i = chunk.indexOf(0x0a);
+      i !== -1;
+      i = chunk.indexOf(0x0a, start)
+    ) {
+      pieces.push(chunk.subarray(start, i));
+      start = i + 1;
+    }
+    pieces.push(chunk.subarray(start));
+    if (pieces.length === 1 && pos > 0) {
+      carryParts.push(chunk);
+      return;
+    }
+    const last = pieces.length - 1;
+    pieces[last] = Buffer.concat([pieces[last], ...carryParts.reverse()]);
+    carryParts = pos > 0 ? [pieces.shift()] : [];
+    queue = pieces.map((piece) => piece.toString("utf-8"));
+    if (pos === 0) {
+      leadingBlank = 0;
+      while (leadingBlank < queue.length && queue[leadingBlank].trim() === "") {
+        leadingBlank++;
+      }
+    }
+  }
+
+  // 옛 trim() 은 파일 맨 앞의 공백과 빈 줄을 지운다. 이미 읽은 줄만으로 알 수 있을 때만 적용해
+  // 앞선 큰 줄을 미리 읽지 않는다.
+  const isFileHead = () => leadingBlank >= 0 && queue.length <= leadingBlank;
+
+  const reader = {
+    bytesRead: 0,
+    // 줄이 더 없으면 null
+    next() {
+      let line = null;
+      while (queue.length > 0 || pos > 0) {
+        if (queue.length === 0) {
+          fill();
+          continue;
+        }
+        line = queue.pop();
+        const blank = line.trim() === "";
+        if (blank && (trimmingTail || isFileHead())) {
+          line = null;
+          continue;
+        }
+        break;
+      }
+      if (line === null) {
+        if (yielded || emptyGiven) return null;
+        emptyGiven = true; // 빈 파일도 옛 split 처럼 빈 줄 하나를 낸다
+        return "";
+      }
+      yielded = true;
+      if (trimmingTail) {
+        trimmingTail = false;
+        line = line.trimEnd();
+      }
+      return isFileHead() ? line.trimStart() : line;
+    },
+    close() {
+      try {
+        closeSync(fd);
+      } catch {
+        /* 이미 닫힘 */
+      }
+    },
+  };
+  return reader;
+}
+
 // ============================================================================
 // Codex 세션 JSONL에서 실제 rate limits 추출
 // 한계: rate_limits는 세션별 스냅샷이므로 여러 세션 간 토큰 합산은 불가.
@@ -298,50 +410,65 @@ export function getCodexRateLimits({
     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 && !found[rl.limit_id]) {
-              // window_minutes 기준으로 5h/1w 슬롯 정규화
-              const { primary, secondary } = normalizeBuckets(rl);
-              found[rl.limit_id] = {
-                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
-            ) {
-              // 2일 이내 token_count: 합성 버킷 (rate_limits가 null일 때 행 활성화용, stale 방지)
-              syntheticBucket = {
-                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,
-              };
+        const reader = createReverseLineReader(join(sessDir, file));
+        try {
+          let scanned = 0;
+          let bytesAfterFirstBucket = 0;
+          // 다음 줄을 읽기 전에 한도를 본다. 안 볼 줄을 만들려고 큰 줄을 읽지 않기 위해서다.
+          while (
+            scanned < maxLinesPerFile &&
+            bytesAfterFirstBucket < EXTRA_BYTES_AFTER_FIRST_BUCKET
+          ) {
+            const line = reader.next();
+            if (line === null) break;
+            scanned++;
+            // 같은 시점의 다른 limit_id 는 인접해 기록된다. 첫 버킷을 찾은 뒤에는 일정 바이트만 더 보고 멈춰,
+            // 단일 버킷 계정에서 800줄(파일 거의 전체)을 끝까지 읽지 않는다.
+            if (Object.keys(found).length > 0) {
+              bytesAfterFirstBucket += Buffer.byteLength(line) + 1;
+            }
+            try {
+              const evt = JSON.parse(line);
+              const rl = evt?.payload?.rate_limits;
+              if (rl?.limit_id && !found[rl.limit_id]) {
+                // window_minutes 기준으로 5h/1w 슬롯 정규화
+                const { primary, secondary } = normalizeBuckets(rl);
+                found[rl.limit_id] = {
+                  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
+              ) {
+                // 2일 이내 token_count: 합성 버킷 (rate_limits가 null일 때 행 활성화용, stale 방지)
+                syntheticBucket = {
+                  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(found).length >= CODEX_MIN_BUCKETS) break;
           }
-          if (Object.keys(found).length >= CODEX_MIN_BUCKETS) break;
+        } finally {
+          reader.close();
         }
         daySnapshots.push(...Object.values(found));
       } catch {

package/hud/utils.mjs

@@ -86,10 +86,6 @@ export function padAnsiRight(text, width) {
   return padAnsi(text, width, "right");
 }
 
-export function padAnsiLeft(text, width) {
-  return padAnsi(text, width, "left");
-}
-
 export function fitText(text, width) {
   const t = String(text || "");
   if (t.length <= width) return t;
@@ -186,20 +182,6 @@ export function formatTokenCount(n) {
   return String(n);
 }
 
-export function getContextPercent(stdin) {
-  const nativePercent = stdin?.context_window?.used_percentage;
-  if (typeof nativePercent === "number" && Number.isFinite(nativePercent))
-    return clampPercent(nativePercent);
-  const usage = stdin?.context_window?.current_usage || {};
-  const totalTokens =
-    Number(usage.input_tokens || 0) +
-    Number(usage.cache_creation_input_tokens || 0) +
-    Number(usage.cache_read_input_tokens || 0);
-  const capacity = Number(stdin?.context_window?.context_window_size || 0);
-  if (!capacity || capacity <= 0) return 0;
-  return clampPercent((totalTokens / capacity) * 100);
-}
-
 // 과거 리셋 시간 → 다음 주기로 순환하여 미래 시점 반환
 // elapsed가 cycleMs의 정수배일 때 ceil은 target=now를 반환해 diff=0이 되므로
 // floor+1로 항상 다음 사이클을 가리키도록 한다.
@@ -240,11 +222,6 @@ export function formatResetRemaining(isoOrUnix, cycleMs = 0) {
   return `${totalHours}h${String(minutes).padStart(2, "0")}m`;
 }
 
-export function isResetPast(isoOrUnix) {
-  const date = parseResetDate(isoOrUnix);
-  return date != null && date.getTime() <= Date.now();
-}
-
 export function formatResetRemainingDayHour(isoOrUnix, cycleMs = 0) {
   const diffMs = getRemainingResetMs(isoOrUnix, cycleMs);
   if (diffMs == null || diffMs <= 0) return "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/core",
-  "version": "10.53.0",
+  "version": "10.55.0",
   "description": "triflux core — CLI routing, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",
@@ -10,7 +10,7 @@
     "./scripts/*": "./scripts/*"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5"

package/scripts/lib/backup-rotation.mjs

@@ -0,0 +1,60 @@
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+// 설정이 바뀔 때마다 백업이 쌓여 끝없이 늘었다. 같은 대상의 백업은 최근 몇 개만 남긴다.
+export const BACKUP_KEEP = 5;
+
+// 시각 suffix 만 받는다. label 이 더 긴 다른 백업(예: <label>-manual-...)은 남긴다.
+const STAMP_SUFFIX = /^[\dT]+(?:-\d+)*$/i;
+
+// 읽는 사이 다른 프로세스가 지웠으면 같은 것으로 보고 아래에서 다시 쓴다. 다른 읽기 오류는 그대로 던진다.
+function sameContent(path, content) {
+  try {
+    return readFileSync(path, "utf8") === content;
+  } catch (error) {
+    if (error?.code === "ENOENT") return true;
+    throw error;
+  }
+}
+
+// `<파일>.<label>-<시각>` 으로 백업하고, 같은 label 의 오래된 백업을 지운다.
+export function writeRotatedBackup(
+  path,
+  content,
+  { label, suffix, mode, keep = BACKUP_KEEP },
+) {
+  const directory = dirname(path);
+  const prefix = `${basename(path)}.${label}-`;
+  // 같은 시각 이름에 다른 원문이 이미 있으면 번호를 붙여 따로 남긴다.
+  let backupPath = join(directory, `${prefix}${suffix}`);
+  for (let i = 1; existsSync(backupPath); i++) {
+    if (sameContent(backupPath, content)) break;
+    backupPath = join(directory, `${prefix}${suffix}-${i}`);
+  }
+  if (!existsSync(backupPath))
+    writeFileSync(backupPath, content, { encoding: "utf8", mode });
+  const backups = readdirSync(directory)
+    .filter(
+      (name) =>
+        name.startsWith(prefix) && STAMP_SUFFIX.test(name.slice(prefix.length)),
+    )
+    .flatMap((name) => {
+      // 다른 프로세스가 같은 백업을 먼저 지웠을 수 있다.
+      try {
+        return [{ name, mtime: statSync(join(directory, name)).mtimeMs }];
+      } catch {
+        return [];
+      }
+    })
+    .sort((a, b) => b.mtime - a.mtime || b.name.localeCompare(a.name));
+  for (const { name } of backups.slice(keep))
+    rmSync(join(directory, name), { force: true });
+  return backupPath;
+}

package/scripts/lib/codex-profile-config.mjs

@@ -3,10 +3,12 @@ import {
   mkdirSync,
   readFileSync,
   renameSync,
+  statSync,
   writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { writeRotatedBackup } from "./backup-rotation.mjs";
 
 const EFFORT_BY_SUFFIX = {
   ultra: "ultra",
@@ -80,10 +82,6 @@ function readProfileScalar(raw, key) {
  * naming convention when the file is absent. Returns the keys that resolve, in
  * `key="value"` TOML-scalar form ready to be shell-quoted by the caller.
  *
- * NOTE: the Codex MCP transport does the structured-arg equivalent in
- * hub/workers/codex-mcp.mjs (resolveCodexProfileConfig → model + config object);
- * this returns the CLI `-c` string form for the same per-profile file.
- *
  * @param {string} profileName
  * @param {{ codexHome?: string }} [opts]
  * @returns {string[]} e.g. ['model="gpt-6.1-sol"', 'model_reasoning_effort="high"']
@@ -230,7 +228,8 @@ export function sanitizeCodexProfileConfig(
         skippedProfileFiles.push(profileName);
         continue;
       }
-      writeFileSync(profilePath, body, "utf8");
+      // 옮겨 온 프로필 본문에 MCP env 키가 있을 수 있다.
+      writeFileSync(profilePath, body, { encoding: "utf8", mode: 0o600 });
       migratedProfiles.push(profileName);
     }
   }
@@ -254,6 +253,15 @@ function stamp(now = () => new Date()) {
     .replace("T", "-");
 }
 
+// config.toml 에는 MCP env 키가 들어갈 수 있다. 다시 쓸 때 원본 권한을 지키고 없으면 0600 으로 만든다.
+export function privateFileMode(path) {
+  try {
+    return statSync(path).mode & 0o777;
+  } catch {
+    return 0o600;
+  }
+}
+
 export function sanitizeCodexProfileConfigFile(
   configPath,
   {
@@ -268,7 +276,12 @@ export function sanitizeCodexProfileConfigFile(
   const source = readFileSync(configPath, "utf8");
   const sanitized = sanitizeCodexProfileConfig(source, { codexHome });
   if (!sanitized.changed) return sanitized;
-  writeFileSync(`${configPath}.${backupPrefix}-${stamp(now)}`, source, "utf8");
+  const mode = privateFileMode(configPath);
+  writeRotatedBackup(configPath, source, {
+    label: backupPrefix,
+    suffix: stamp(now),
+    mode,
+  });
   // Atomic replace. config.toml is shared global state: a codex session may be
   // reading it while another entry point (tfx-route, the codex session hook, or
   // a parallel swarm worker) sanitizes it. Write the sanitized content to a
@@ -278,7 +291,7 @@ export function sanitizeCodexProfileConfigFile(
   // without corruption (the content is identical anyway since the migration is
   // deterministic). The pid keeps temp names unique across separate processes.
   const tmpPath = `${configPath}.tmp-${process.pid}-${stamp(now)}`;
-  writeFileSync(tmpPath, sanitized.toml, "utf8");
+  writeFileSync(tmpPath, sanitized.toml, { encoding: "utf8", mode });
   renameSync(tmpPath, configPath);
   return sanitized;
 }

package/scripts/lib/codex-recovery.sh

@@ -58,9 +58,8 @@ recover_codex_stdout() {
 
 # ── MCP transport 채널 사망 판정 ──
 # Codex MCP transport 채널이 실행 중 죽으면 codex exec 가 exit 0 + 빈 stdout 으로
-# 끝나는 변형이 있다(래퍼 부재로 인한 pre-flight CODEX_MCP_TRANSPORT_EXIT_CODE=70
-# 과 구분됨 — 이건 런타임 채널 사망). stderr 의 하드 크래시 서명으로 이 사망을
-# 검출한다. 아우터 가드가 exit 0 이어도 결과를 실패로 승격하는 근거로 쓴다.
+# 끝나는 변형이 있다. stderr 의 하드 크래시 서명으로 이 사망을 검출한다.
+# 아우터 가드가 exit 0 이어도 결과를 실패로 승격하는 근거로 쓴다.
 # 인자: [stderr_log] (미지정 시 $STDERR_LOG). 반환: 0=크래시 서명 있음, 1=없음.
 codex_stdout_transport_crashed() {
   local stderr_log="${1:-${STDERR_LOG:-}}"