@praeviso/code-env-switch 0.1.8 → 0.1.9

package/bin/usage/index.js

@@ -16,6 +16,7 @@ exports.syncUsageFromStatuslineInput = syncUsageFromStatuslineInput;
 exports.logProfileUse = logProfileUse;
 exports.logSessionBinding = logSessionBinding;
 exports.readSessionBindingIndex = readSessionBindingIndex;
+exports.resolveProfileFromLog = resolveProfileFromLog;
 exports.clearUsageHistory = clearUsageHistory;
 exports.readUsageRecords = readUsageRecords;
 exports.syncUsageFromSessions = syncUsageFromSessions;
@@ -375,16 +376,15 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
         cacheWriteTokens;
     if (!Number.isFinite(totalTokens))
         return;
-    const statePath = getUsageStatePath(usagePath, config);
-    const lockPath = `${statePath}.lock`;
+    const sessionKey = buildSessionKey(normalizedType, sessionId);
+    const sessionStatePath = getUsageSessionStatePath(usagePath, sessionKey);
+    const legacySessionStatePath = getLegacyUsageSessionStatePath(usagePath, sessionKey);
+    const lockPath = `${sessionStatePath}.lock`;
     const lockFd = acquireLock(lockPath);
     if (lockFd === null)
         return;
     try {
-        const state = readUsageState(statePath);
-        const sessions = state.sessions || {};
-        const key = buildSessionKey(normalizedType, sessionId);
-        const prev = sessions[key];
+        const prev = readUsageSessionStateWithFallback(sessionStatePath, legacySessionStatePath);
         const prevInput = prev ? toUsageNumber(prev.inputTokens) : 0;
         const prevOutput = prev ? toUsageNumber(prev.outputTokens) : 0;
         const prevCacheRead = prev ? toUsageNumber(prev.cacheReadTokens) : 0;
@@ -396,12 +396,11 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
         let deltaCacheWrite = cacheWriteTokens - prevCacheWrite;
         let deltaTotal = totalTokens - prevTotal;
         if (deltaTotal < 0) {
-            // Session reset: treat current totals as fresh usage.
-            deltaInput = inputTokens;
-            deltaOutput = outputTokens;
-            deltaCacheRead = cacheReadTokens;
-            deltaCacheWrite = cacheWriteTokens;
-            deltaTotal = totalTokens;
+            deltaInput = 0;
+            deltaOutput = 0;
+            deltaCacheRead = 0;
+            deltaCacheWrite = 0;
+            deltaTotal = 0;
         }
         else {
             // Clamp negatives caused by reclassification (e.g. cache splits).
@@ -438,13 +437,18 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
             appendUsageRecord(usagePath, record);
         }
         const now = new Date().toISOString();
-        sessions[key] = {
+        const nextInput = Math.max(prevInput, inputTokens);
+        const nextOutput = Math.max(prevOutput, outputTokens);
+        const nextCacheRead = Math.max(prevCacheRead, cacheReadTokens);
+        const nextCacheWrite = Math.max(prevCacheWrite, cacheWriteTokens);
+        const nextTotal = Math.max(prevTotal, totalTokens);
+        const nextSession = {
             type: normalizedType,
-            inputTokens,
-            outputTokens,
-            cacheReadTokens,
-            cacheWriteTokens,
-            totalTokens,
+            inputTokens: nextInput,
+            outputTokens: nextOutput,
+            cacheReadTokens: nextCacheRead,
+            cacheWriteTokens: nextCacheWrite,
+            totalTokens: nextTotal,
             startTs: prev ? prev.startTs : now,
             endTs: now,
             cwd: cwd || (prev ? prev.cwd : null),
@@ -452,9 +456,7 @@ function syncUsageFromStatuslineInput(config, configPath, type, profileKey, prof
             profileKey: profileKey || null,
             profileName: profileName || null,
         };
-        state.sessions = sessions;
-        updateUsageStateMetadata(state, usagePath);
-        writeUsageState(statePath, state);
+        writeUsageSessionState(sessionStatePath, nextSession);
     }
     finally {
         releaseLock(lockPath, lockFd);
@@ -596,6 +598,42 @@ function resolveProfileForSession(config, logEntries, type, sessionFile, session
     }
     return { match: null, ambiguous: false };
 }
+function resolveProfileFromLog(config, configPath, type, terminalTag) {
+    const normalizedType = (0, type_1.normalizeType)(type || "");
+    if (!normalizedType)
+        return null;
+    const profileLogPath = getProfileLogPath(config, configPath);
+    const entries = readProfileLogEntries([profileLogPath]);
+    if (entries.length === 0)
+        return null;
+    if (!terminalTag)
+        return null;
+    let best = null;
+    let bestTime = Number.NEGATIVE_INFINITY;
+    for (const entry of entries) {
+        if (entry.kind !== "use")
+            continue;
+        if (entry.profileType !== normalizedType)
+            continue;
+        if (entry.terminalTag !== terminalTag)
+            continue;
+        if (!entry.profileKey && !entry.profileName)
+            continue;
+        const ts = new Date(entry.timestamp).getTime();
+        if (!Number.isFinite(ts))
+            continue;
+        if (ts >= bestTime) {
+            bestTime = ts;
+            best = entry;
+        }
+    }
+    if (!best)
+        return null;
+    const match = normalizeProfileMatch(config, best, normalizedType);
+    if (!match.profileKey && !match.profileName)
+        return null;
+    return match;
+}
 function readUsageState(statePath) {
     if (!statePath || !fs.existsSync(statePath)) {
         return { version: 1, files: {}, sessions: {} };
@@ -644,6 +682,54 @@ function writeUsageState(statePath, state) {
         fs.writeFileSync(statePath, payload, "utf8");
     }
 }
+function getUsageSessionStateDir(usagePath) {
+    const dir = path.dirname(usagePath);
+    const base = path.basename(usagePath, path.extname(usagePath));
+    return path.join(dir, `${base}-sessions`);
+}
+function getLegacyUsageSessionStateDir(usagePath) {
+    return `${usagePath}.sessions`;
+}
+function toSafeSessionKey(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function getUsageSessionStatePath(usagePath, sessionKey) {
+    const dir = getUsageSessionStateDir(usagePath);
+    return path.join(dir, `${toSafeSessionKey(sessionKey)}.json`);
+}
+function getLegacyUsageSessionStatePath(usagePath, sessionKey) {
+    const dir = getLegacyUsageSessionStateDir(usagePath);
+    return path.join(dir, `${toSafeSessionKey(sessionKey)}.json`);
+}
+function readUsageSessionState(filePath) {
+    var _a;
+    if (!filePath || !fs.existsSync(filePath))
+        return null;
+    try {
+        const raw = fs.readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const session = (_a = parsed.session) !== null && _a !== void 0 ? _a : parsed;
+        if (!session || typeof session !== "object")
+            return null;
+        return session;
+    }
+    catch {
+        return null;
+    }
+}
+function readUsageSessionStateWithFallback(primaryPath, legacyPath) {
+    return readUsageSessionState(primaryPath) || readUsageSessionState(legacyPath);
+}
+function writeUsageSessionState(filePath, session) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const payload = { version: 1, session };
+    fs.writeFileSync(filePath, `${JSON.stringify(payload)}\n`, "utf8");
+}
 function addSiblingBackupPaths(targets, filePath) {
     if (!filePath)
         return;
@@ -672,6 +758,22 @@ function clearUsageHistory(config, configPath) {
     if (usagePath) {
         targets.add(usagePath);
         addSiblingBackupPaths(targets, usagePath);
+        for (const sessionDir of [
+            getUsageSessionStateDir(usagePath),
+            getLegacyUsageSessionStateDir(usagePath),
+        ]) {
+            try {
+                const entries = fs.readdirSync(sessionDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isFile())
+                        continue;
+                    targets.add(path.join(sessionDir, entry.name));
+                }
+            }
+            catch {
+                // ignore session state cleanup failures
+            }
+        }
     }
     const statePath = usagePath ? getUsageStatePath(usagePath, config) : null;
     if (statePath) {

package/code-env.example.json

@@ -5,10 +5,7 @@
     "claude": "default"
   },
   "codexStatusline": {
-    "command": ["codenv", "statusline", "--type", "codex", "--sync-usage"],
-    "showHints": false,
-    "updateIntervalMs": 300,
-    "timeoutMs": 1000
+    "items": ["model-with-reasoning", "context-remaining", "current-dir", "git-branch"]
   },
   "claudeStatusline": {
     "command": "codenv statusline --type claude --sync-usage",

package/docs/usage.md

@@ -56,6 +56,9 @@ Each line is a JSON object (fields may be null/omitted depending on the source):
 To see real payloads, set `CODE_ENV_STATUSLINE_DEBUG=1` and read the JSONL entries in
 `statusline-debug.jsonl` (or the path from `CODE_ENV_STATUSLINE_DEBUG_PATH`).
 
+Note: with official Codex status line configuration (`tui.status_line`), Codex does not invoke
+an external status line command by default.
+
 ### Codex (token_usage totals)
 
 ```json

package/docs/usage_zh.md

@@ -56,6 +56,8 @@
 可通过设置 `CODE_ENV_STATUSLINE_DEBUG=1`，在 `statusline-debug.jsonl`
 （或 `CODE_ENV_STATUSLINE_DEBUG_PATH` 指定路径）看到实际 JSON。
 
+注意：使用官方 Codex 状态栏配置（`tui.status_line`）时，Codex 默认不会调用外部状态栏命令。
+
 ### Codex（token_usage totals）
 
 ```json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praeviso/code-env-switch",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Switch between Claude Code and Codex environment variables from a single CLI",
   "bin": {
     "codenv": "bin/index.js"
@@ -17,9 +17,9 @@
   },
   "devDependencies": {
     "@types/node": "^20.11.0",
-    "@typescript-eslint/eslint-plugin": "^6.21.0",
-    "@typescript-eslint/parser": "^6.21.0",
-    "eslint": "^8.57.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "eslint": "^10.0.2",
     "typescript": "^5.9.3"
   }
 }

package/src/commands/list.ts

@@ -6,10 +6,12 @@ import { buildListRows } from "../profile/display";
 import { getResolvedDefaultProfileKeys } from "../config/defaults";
 import {
     formatTokenCount,
+    getUsagePath,
     readUsageCostIndex,
     readUsageTotalsIndex,
     resolveUsageCostForProfile,
     resolveUsageTotalsForProfile,
+    syncUsageFromSessions,
 } from "../usage";
 import { formatUsdAmount } from "../usage/pricing";
 
@@ -20,7 +22,15 @@ export function printList(config: Config, configPath: string | null): void {
         return;
     }
     try {
-        const usageTotals = readUsageTotalsIndex(config, configPath, true);
+        const usagePath = getUsagePath(config, configPath);
+        if (usagePath) {
+            syncUsageFromSessions(config, configPath, usagePath);
+        }
+    } catch {
+        // ignore usage sync errors
+    }
+    try {
+        const usageTotals = readUsageTotalsIndex(config, configPath, false);
         const usageCosts = readUsageCostIndex(config, configPath, false);
         if (usageTotals) {
             for (const row of rows) {