@praeviso/code-env-switch 0.1.8 → 0.1.10

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",
@@ -74,7 +71,7 @@
     "p_a1b2c3": {
       "name": "primary",
       "type": "codex",
-      "note": "Primary endpoint",
+      "note": "Primary endpoint (applied via ~/.codex/config.toml)",
       "env": {
         "OPENAI_BASE_URL": "https://api.example.com/v1",
         "OPENAI_API_KEY": "YOUR_API_KEY"
@@ -86,7 +83,7 @@
     "p_d4e5f6": {
       "name": "secondary",
       "type": "codex",
-      "note": "Secondary endpoint",
+      "note": "Secondary endpoint (applied via ~/.codex/config.toml)",
       "env": {
         "OPENAI_BASE_URL": "https://api.secondary.example.com/v1",
         "OPENAI_API_KEY": "YOUR_API_KEY"

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,7 +1,7 @@
 {
   "name": "@praeviso/code-env-switch",
-  "version": "0.1.8",
-  "description": "Switch between Claude Code and Codex environment variables from a single CLI",
+  "version": "0.1.10",
+  "description": "Switch between Claude Code and Codex profiles 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/cli/help.ts

@@ -3,7 +3,7 @@
  */
 
 export function printHelp(): void {
-    const msg = `codenv - switch Claude/Codex env vars
+    const msg = `codenv - switch Claude/Codex profiles
 
 Usage:
   codenv list

package/src/codex/config.ts

@@ -0,0 +1,309 @@
+/**
+ * Codex provider configuration management
+ */
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import type { Config, EnvValue } from "../types";
+import { CODEX_AUTH_PATH } from "../constants";
+import { getProfileDisplayName, inferProfileType } from "../profile/type";
+import { expandEnv, resolvePath } from "../shell/utils";
+
+const DEFAULT_CODEX_CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
+const CODEX_PROVIDER_NAME = "OpenAI";
+const CODEX_PROVIDER_WIRE_API = "responses";
+
+interface TomlSectionRange {
+    start: number;
+    end: number;
+    sectionText: string;
+}
+
+interface CodexProviderBackup {
+    version: number;
+    modelProviderLine: string | null;
+    providerSectionText: string | null;
+    authText: string | null;
+}
+
+function normalizeEnvValue(value: EnvValue): string | null {
+    if (value === null || value === undefined) return null;
+    const normalized = String(value).trim();
+    return normalized ? normalized : null;
+}
+
+function readTextIfExists(filePath: string): string | null {
+    if (!fs.existsSync(filePath)) return null;
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    } catch {
+        return null;
+    }
+}
+
+function writeText(filePath: string, text: string): void {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, text, "utf8");
+}
+
+function removeFileIfExists(filePath: string): void {
+    if (!fs.existsSync(filePath)) return;
+    try {
+        fs.unlinkSync(filePath);
+    } catch {
+        // ignore cleanup failures
+    }
+}
+
+function getBackupPath(configPath: string): string {
+    return `${configPath}.codenv-provider-backup.json`;
+}
+
+function readBackup(backupPath: string): CodexProviderBackup | null {
+    const raw = readTextIfExists(backupPath);
+    if (!raw) return null;
+    try {
+        const parsed = JSON.parse(raw) as Partial<CodexProviderBackup>;
+        return {
+            version:
+                typeof parsed.version === "number" ? parsed.version : 1,
+            modelProviderLine:
+                typeof parsed.modelProviderLine === "string"
+                    ? parsed.modelProviderLine
+                    : null,
+            providerSectionText:
+                typeof parsed.providerSectionText === "string"
+                    ? parsed.providerSectionText
+                    : null,
+            authText: typeof parsed.authText === "string" ? parsed.authText : null,
+        };
+    } catch {
+        return null;
+    }
+}
+
+function writeBackup(backupPath: string, backup: CodexProviderBackup): void {
+    writeText(backupPath, `${JSON.stringify(backup, null, 2)}\n`);
+}
+
+function parseSectionByHeader(
+    text: string,
+    headerRegex: RegExp
+): TomlSectionRange | null {
+    const match = headerRegex.exec(text);
+    if (!match || match.index === undefined) return null;
+
+    const start = match.index;
+    const afterHeader = start + match[0].length;
+    const rest = text.slice(afterHeader);
+    const nextHeaderMatch = rest.match(/^\s*\[.*?\]\s*$/m);
+    const end = nextHeaderMatch
+        ? afterHeader + (nextHeaderMatch.index ?? rest.length)
+        : text.length;
+    return {
+        start,
+        end,
+        sectionText: text.slice(start, end).trimEnd(),
+    };
+}
+
+function getFirstSectionIndex(text: string): number {
+    const match = text.match(/^\s*\[.*?\]\s*$/m);
+    if (!match || match.index === undefined) return text.length;
+    return match.index;
+}
+
+function getRootText(text: string): { root: string; rest: string } {
+    const index = getFirstSectionIndex(text);
+    return {
+        root: text.slice(0, index),
+        rest: text.slice(index),
+    };
+}
+
+function readModelProviderLine(text: string): string | null {
+    const { root } = getRootText(text);
+    const match = root.match(/^\s*model_provider\s*=.*$/m);
+    return match ? match[0].trimEnd() : null;
+}
+
+function removeModelProviderLine(text: string): string {
+    const { root, rest } = getRootText(text);
+    const updatedRoot = root.replace(/^\s*model_provider\s*=.*(?:\r?\n)?/m, "");
+    return `${updatedRoot}${rest}`;
+}
+
+function insertRootLine(text: string, line: string): string {
+    const { root, rest } = getRootText(text);
+    const trimmedRoot = root.trimEnd();
+    const trimmedRest = rest.trimStart();
+
+    if (!trimmedRoot) {
+        if (!trimmedRest) return `${line}\n`;
+        return `${line}\n\n${trimmedRest}`;
+    }
+
+    if (!trimmedRest) {
+        return `${trimmedRoot}\n${line}\n`;
+    }
+
+    return `${trimmedRoot}\n${line}\n\n${trimmedRest}`;
+}
+
+function removeSection(text: string, headerRegex: RegExp): string {
+    const range = parseSectionByHeader(text, headerRegex);
+    if (!range) return text;
+    const before = text.slice(0, range.start).trimEnd();
+    const after = text.slice(range.end).trimStart();
+    if (before && after) return `${before}\n\n${after}`;
+    if (before) return `${before}\n`;
+    if (after) return `${after}\n`;
+    return "";
+}
+
+function appendSection(text: string, sectionText: string): string {
+    const trimmed = text.trimEnd();
+    if (!trimmed) return `${sectionText}\n`;
+    return `${trimmed}\n\n${sectionText}\n`;
+}
+
+function getProviderHeaderRegex(): RegExp {
+    return /^\s*\[model_providers\.OpenAI\]\s*$/m;
+}
+
+function readProviderSectionText(text: string): string | null {
+    const range = parseSectionByHeader(text, getProviderHeaderRegex());
+    return range ? range.sectionText : null;
+}
+
+function renderProviderSection(baseUrl: string | null): string {
+    const lines = [
+        `[model_providers.${CODEX_PROVIDER_NAME}]`,
+        `name = ${JSON.stringify(CODEX_PROVIDER_NAME)}`,
+    ];
+    if (baseUrl) {
+        lines.push(`base_url = ${JSON.stringify(baseUrl)}`);
+    }
+    lines.push(`wire_api = ${JSON.stringify(CODEX_PROVIDER_WIRE_API)}`);
+    lines.push("requires_openai_auth = true");
+    return lines.join("\n");
+}
+
+function ensureBackup(configPath: string, currentConfigText: string): void {
+    const backupPath = getBackupPath(configPath);
+    if (readBackup(backupPath)) return;
+    writeBackup(backupPath, {
+        version: 1,
+        modelProviderLine: readModelProviderLine(currentConfigText),
+        providerSectionText: readProviderSectionText(currentConfigText),
+        authText: readTextIfExists(CODEX_AUTH_PATH),
+    });
+}
+
+function writeManagedConfig(configPath: string, baseUrl: string | null): void {
+    const currentText = readTextIfExists(configPath) || "";
+    ensureBackup(configPath, currentText);
+
+    let updated = currentText;
+    updated = removeSection(updated, getProviderHeaderRegex());
+    updated = removeModelProviderLine(updated);
+    updated = insertRootLine(
+        updated,
+        `model_provider = ${JSON.stringify(CODEX_PROVIDER_NAME)}`
+    );
+    updated = appendSection(updated, renderProviderSection(baseUrl));
+    writeText(configPath, updated);
+}
+
+function writeManagedAuth(apiKey: string | null): void {
+    const authJson =
+        apiKey === null
+            ? "null"
+            : JSON.stringify({ OPENAI_API_KEY: apiKey });
+    writeText(CODEX_AUTH_PATH, `${authJson}\n`);
+}
+
+function restoreAuth(authText: string | null): void {
+    if (authText === null) {
+        removeFileIfExists(CODEX_AUTH_PATH);
+        return;
+    }
+    writeText(CODEX_AUTH_PATH, authText);
+}
+
+export function resolveCodexConfigPath(config: Config): string {
+    const envOverride = process.env.CODE_ENV_CODEX_CONFIG_PATH;
+    if (envOverride && String(envOverride).trim()) {
+        const expanded = expandEnv(String(envOverride).trim());
+        return resolvePath(expanded) || DEFAULT_CODEX_CONFIG_PATH;
+    }
+    const configOverride = config.codexStatusline?.configPath;
+    if (configOverride && String(configOverride).trim()) {
+        const expanded = expandEnv(String(configOverride).trim());
+        return resolvePath(expanded) || DEFAULT_CODEX_CONFIG_PATH;
+    }
+    return DEFAULT_CODEX_CONFIG_PATH;
+}
+
+export function syncCodexProfile(config: Config, profileName: string): void {
+    const profile = config.profiles && config.profiles[profileName];
+    if (!profile) {
+        throw new Error(`Unknown profile: ${profileName}`);
+    }
+    const env = profile.env || {};
+    const baseUrl = normalizeEnvValue(env.OPENAI_BASE_URL);
+    const apiKey = normalizeEnvValue(env.OPENAI_API_KEY);
+    const configPath = resolveCodexConfigPath(config);
+    writeManagedConfig(configPath, baseUrl);
+    writeManagedAuth(apiKey);
+}
+
+export function clearManagedCodexProfile(config: Config): void {
+    const configPath = resolveCodexConfigPath(config);
+    const backupPath = getBackupPath(configPath);
+    const backup = readBackup(backupPath);
+    if (!backup) return;
+
+    let updated = readTextIfExists(configPath) || "";
+    updated = removeSection(updated, getProviderHeaderRegex());
+    updated = removeModelProviderLine(updated);
+    if (backup.modelProviderLine) {
+        updated = insertRootLine(updated, backup.modelProviderLine);
+    }
+    if (backup.providerSectionText) {
+        updated = appendSection(updated, backup.providerSectionText);
+    }
+
+    const trimmed = updated.trimEnd();
+    if (trimmed) {
+        writeText(configPath, `${trimmed}\n`);
+    } else {
+        removeFileIfExists(configPath);
+    }
+
+    restoreAuth(backup.authText);
+    removeFileIfExists(backupPath);
+}
+
+export function resolveCodexProfileFromEnv(
+    config: Config,
+    profileKey: string | null,
+    profileName: string | null
+): string | null {
+    const profiles = config.profiles || {};
+    if (profileKey && profiles[profileKey]) return profileKey;
+    if (!profileName) return null;
+
+    for (const [key, profile] of Object.entries(profiles)) {
+        if (inferProfileType(key, profile || {}, null) !== "codex") continue;
+        const displayName = getProfileDisplayName(key, profile || {}, "codex");
+        if (displayName === profileName || key === profileName) {
+            return key;
+        }
+    }
+
+    return null;
+}

package/src/commands/launch.ts

@@ -5,7 +5,6 @@ import * as fs from "fs";
 import * as path from "path";
 import { spawn } from "child_process";
 import type { Config, ProfileType } from "../types";
-import { CODEX_AUTH_PATH } from "../constants";
 import { normalizeType } from "../profile/type";
 import {
     getCodexSessionsPath,
@@ -16,6 +15,7 @@ import {
 } from "../usage";
 import { ensureClaudeStatusline } from "../statusline/claude";
 import { ensureCodexStatuslineConfig } from "../statusline/codex";
+import { resolveCodexProfileFromEnv, syncCodexProfile } from "../codex/config";
 
 const SESSION_BINDING_POLL_MS = 1000;
 const SESSION_BINDING_START_GRACE_MS = 5000;
@@ -203,24 +203,6 @@ function getProfileEnv(type: ProfileType): { key: string | null; name: string |
     return { key, name };
 }
 
-function writeCodexAuthFromEnv(): void {
-    const apiKey = process.env.OPENAI_API_KEY;
-    try {
-        fs.mkdirSync(path.dirname(CODEX_AUTH_PATH), { recursive: true });
-    } catch {
-        // ignore
-    }
-    const authJson =
-        apiKey === null || apiKey === undefined || apiKey === ""
-            ? "null"
-            : JSON.stringify({ OPENAI_API_KEY: String(apiKey) });
-    try {
-        fs.writeFileSync(CODEX_AUTH_PATH, `${authJson}\n`, "utf8");
-    } catch {
-        // ignore
-    }
-}
-
 function parseBooleanEnv(value: string | undefined): boolean | null {
     if (value === undefined) return null;
     const normalized = String(value).trim().toLowerCase();
@@ -259,11 +241,18 @@ export async function runLaunch(
     if (!type) {
         throw new Error(`Unknown launch target: ${target}`);
     }
+    const { key: profileKey, name: profileName } = getProfileEnv(type);
     if (type === "codex") {
-        writeCodexAuthFromEnv();
+        const codexProfileKey = resolveCodexProfileFromEnv(
+            config,
+            profileKey,
+            profileName
+        );
+        if (codexProfileKey) {
+            syncCodexProfile(config, codexProfileKey);
+        }
     }
 
-    const { key: profileKey, name: profileName } = getProfileEnv(type);
     const terminalTag = process.env.CODE_ENV_TERMINAL_TAG || null;
     const cwd = process.cwd();
     const startMs = Date.now();

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) {