@praeviso/code-env-switch 0.1.1 → 0.1.3

package/bin/usage/index.js

@@ -0,0 +1,832 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUsagePath = getUsagePath;
+exports.getUsageStatePath = getUsageStatePath;
+exports.getProfileLogPath = getProfileLogPath;
+exports.getCodexSessionsPath = getCodexSessionsPath;
+exports.getClaudeSessionsPath = getClaudeSessionsPath;
+exports.formatTokenCount = formatTokenCount;
+exports.buildUsageTotals = buildUsageTotals;
+exports.readUsageTotalsIndex = readUsageTotalsIndex;
+exports.resolveUsageTotalsForProfile = resolveUsageTotalsForProfile;
+exports.syncUsageFromStatuslineInput = syncUsageFromStatuslineInput;
+exports.logProfileUse = logProfileUse;
+exports.logSessionBinding = logSessionBinding;
+exports.readSessionBindingIndex = readSessionBindingIndex;
+exports.readUsageRecords = readUsageRecords;
+exports.syncUsageFromSessions = syncUsageFromSessions;
+/**
+ * Usage tracking utilities
+ */
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const utils_1 = require("../shell/utils");
+const type_1 = require("../profile/type");
+function resolveDefaultConfigDir(configPath) {
+    if (configPath)
+        return path.dirname(configPath);
+    return path.join(os.homedir(), ".config", "code-env");
+}
+function getUsagePath(config, configPath) {
+    if (config && config.usagePath)
+        return (0, utils_1.resolvePath)(config.usagePath);
+    const baseDir = resolveDefaultConfigDir(configPath);
+    return path.join(baseDir, "usage.jsonl");
+}
+function getUsageStatePath(usagePath, config) {
+    if (config && config.usageStatePath)
+        return (0, utils_1.resolvePath)(config.usageStatePath);
+    return `${usagePath}.state.json`;
+}
+function getProfileLogPath(config, configPath) {
+    if (config && config.profileLogPath)
+        return (0, utils_1.resolvePath)(config.profileLogPath);
+    const baseDir = resolveDefaultConfigDir(configPath);
+    return path.join(baseDir, "profile-log.jsonl");
+}
+function getCodexSessionsPath(config) {
+    if (config && config.codexSessionsPath)
+        return (0, utils_1.resolvePath)(config.codexSessionsPath);
+    if (process.env.CODEX_HOME) {
+        return path.join(process.env.CODEX_HOME, "sessions");
+    }
+    return path.join(os.homedir(), ".codex", "sessions");
+}
+function getClaudeSessionsPath(config) {
+    if (config && config.claudeSessionsPath)
+        return (0, utils_1.resolvePath)(config.claudeSessionsPath);
+    if (process.env.CLAUDE_HOME) {
+        return path.join(process.env.CLAUDE_HOME, "projects");
+    }
+    return path.join(os.homedir(), ".claude", "projects");
+}
+function formatTokenCount(value) {
+    if (value === null || value === undefined || !Number.isFinite(value))
+        return "-";
+    if (value < 1000)
+        return `${Math.round(value)}`;
+    if (value < 1000000)
+        return `${(value / 1000).toFixed(2)}K`;
+    if (value < 1000000000)
+        return `${(value / 1000000).toFixed(2)}M`;
+    return `${(value / 1000000000).toFixed(2)}B`;
+}
+function buildUsageTotals(records) {
+    const byKey = new Map();
+    const byName = new Map();
+    const todayStart = new Date();
+    todayStart.setHours(0, 0, 0, 0);
+    const todayStartMs = todayStart.getTime();
+    const tomorrowStart = new Date(todayStart);
+    tomorrowStart.setDate(todayStart.getDate() + 1);
+    const tomorrowStartMs = tomorrowStart.getTime();
+    const isToday = (ts) => {
+        if (!ts)
+            return false;
+        const time = new Date(ts).getTime();
+        if (Number.isNaN(time))
+            return false;
+        return time >= todayStartMs && time < tomorrowStartMs;
+    };
+    const addTotals = (map, key, amount, ts) => {
+        if (!key)
+            return;
+        const current = map.get(key) || { today: 0, total: 0 };
+        current.total += amount;
+        if (isToday(ts))
+            current.today += amount;
+        map.set(key, current);
+    };
+    for (const record of records) {
+        const type = normalizeUsageType(record.type) || "";
+        const total = Number(record.totalTokens || 0);
+        if (!Number.isFinite(total))
+            continue;
+        if (record.profileKey) {
+            addTotals(byKey, `${type}||${record.profileKey}`, total, record.ts);
+        }
+        if (record.profileName) {
+            addTotals(byName, `${type}||${record.profileName}`, total, record.ts);
+        }
+    }
+    return { byKey, byName };
+}
+function normalizeUsageType(type) {
+    if (!type)
+        return null;
+    const normalized = (0, type_1.normalizeType)(type);
+    if (normalized)
+        return normalized;
+    const trimmed = String(type).trim();
+    return trimmed ? trimmed : null;
+}
+function buildSessionKey(type, sessionId) {
+    const normalized = normalizeUsageType(type || "");
+    return normalized ? `${normalized}::${sessionId}` : sessionId;
+}
+function toFiniteNumber(value) {
+    if (value === null || value === undefined)
+        return null;
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return null;
+    return num;
+}
+function buildUsageLookupKey(type, profileId) {
+    if (!profileId)
+        return null;
+    const resolvedType = normalizeUsageType(type);
+    if (!resolvedType)
+        return null;
+    return `${resolvedType}||${profileId}`;
+}
+function readUsageTotalsIndex(config, configPath, syncUsage) {
+    const usagePath = getUsagePath(config, configPath);
+    if (!usagePath)
+        return null;
+    if (syncUsage) {
+        syncUsageFromSessions(config, configPath, usagePath);
+    }
+    const records = readUsageRecords(usagePath);
+    if (records.length === 0)
+        return null;
+    return buildUsageTotals(records);
+}
+function resolveUsageTotalsForProfile(totals, type, profileKey, profileName) {
+    const keyLookup = buildUsageLookupKey(type, profileKey);
+    const nameLookup = buildUsageLookupKey(type, profileName);
+    return ((keyLookup && totals.byKey.get(keyLookup)) ||
+        (nameLookup && totals.byName.get(nameLookup)) ||
+        null);
+}
+function syncUsageFromStatuslineInput(config, configPath, type, profileKey, profileName, sessionId, totals, cwd) {
+    var _a, _b, _c;
+    if (!sessionId)
+        return;
+    if (!totals)
+        return;
+    if (!profileKey && !profileName)
+        return;
+    const normalizedType = (0, type_1.normalizeType)(type || "");
+    if (!normalizedType)
+        return;
+    const usagePath = getUsagePath(config, configPath);
+    if (!usagePath)
+        return;
+    const inputTokens = (_a = toFiniteNumber(totals.inputTokens)) !== null && _a !== void 0 ? _a : 0;
+    const outputTokens = (_b = toFiniteNumber(totals.outputTokens)) !== null && _b !== void 0 ? _b : 0;
+    const totalTokens = (_c = toFiniteNumber(totals.totalTokens)) !== null && _c !== void 0 ? _c : inputTokens + outputTokens;
+    if (!Number.isFinite(totalTokens))
+        return;
+    const statePath = getUsageStatePath(usagePath, config);
+    const lockPath = `${statePath}.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 prevInput = prev ? prev.inputTokens : 0;
+        const prevOutput = prev ? prev.outputTokens : 0;
+        const prevTotal = prev ? prev.totalTokens : 0;
+        let deltaInput = inputTokens - prevInput;
+        let deltaOutput = outputTokens - prevOutput;
+        let deltaTotal = totalTokens - prevTotal;
+        if (deltaTotal < 0 || deltaInput < 0 || deltaOutput < 0) {
+            deltaInput = inputTokens;
+            deltaOutput = outputTokens;
+            deltaTotal = totalTokens;
+        }
+        if (deltaTotal > 0) {
+            const record = {
+                ts: new Date().toISOString(),
+                type: normalizedType,
+                profileKey: profileKey || null,
+                profileName: profileName || null,
+                inputTokens: deltaInput,
+                outputTokens: deltaOutput,
+                totalTokens: deltaTotal,
+            };
+            appendUsageRecord(usagePath, record);
+        }
+        const now = new Date().toISOString();
+        sessions[key] = {
+            type: normalizedType,
+            inputTokens,
+            outputTokens,
+            totalTokens,
+            startTs: prev ? prev.startTs : now,
+            endTs: now,
+            cwd: cwd || (prev ? prev.cwd : null),
+        };
+        state.sessions = sessions;
+        writeUsageState(statePath, state);
+    }
+    finally {
+        releaseLock(lockPath, lockFd);
+    }
+}
+function logProfileUse(config, configPath, profileKey, requestedType, terminalTag, cwd) {
+    const profile = config.profiles && config.profiles[profileKey];
+    if (!profile)
+        return;
+    const inferred = (0, type_1.inferProfileType)(profileKey, profile, requestedType);
+    if (!inferred)
+        return;
+    const displayName = (0, type_1.getProfileDisplayName)(profileKey, profile, requestedType || inferred);
+    appendProfileLogEntry(config, configPath, profileKey, displayName || profileKey, inferred, terminalTag, cwd, "use", null, null, null);
+}
+function logSessionBinding(config, configPath, profileType, profileKey, profileName, terminalTag, cwd, sessionFile, sessionId, sessionTimestamp) {
+    if (!profileKey && !profileName)
+        return;
+    const key = profileKey ? String(profileKey) : "unknown";
+    const name = profileName ? String(profileName) : key;
+    appendProfileLogEntry(config, configPath, key, name, profileType, terminalTag, cwd, "session", sessionFile, sessionId, sessionTimestamp);
+}
+function appendProfileLogEntry(config, configPath, profileKey, profileName, profileType, terminalTag, cwd, kind, sessionFile, sessionId, timestamp) {
+    const logPath = getProfileLogPath(config, configPath);
+    const dir = path.dirname(logPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const record = {
+        timestamp: timestamp || new Date().toISOString(),
+        kind,
+        profileKey,
+        profileName,
+        profileType,
+        configPath: configPath || null,
+        terminalTag: terminalTag || null,
+        cwd: cwd || null,
+        sessionFile: sessionFile || null,
+        sessionId: sessionId || null,
+    };
+    fs.appendFileSync(logPath, `${JSON.stringify(record)}\n`, "utf8");
+}
+function readProfileLogEntries(paths) {
+    var _a;
+    const entries = [];
+    for (const logPath of paths) {
+        if (!logPath || !fs.existsSync(logPath))
+            continue;
+        const raw = fs.readFileSync(logPath, "utf8");
+        const lines = raw.split(/\r?\n/);
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (!parsed || typeof parsed !== "object")
+                    continue;
+                const rawKind = parsed.kind ? String(parsed.kind).toLowerCase() : "";
+                const kind = rawKind === "session" ? "session" : "use";
+                entries.push({
+                    kind,
+                    timestamp: String((_a = parsed.timestamp) !== null && _a !== void 0 ? _a : ""),
+                    profileKey: parsed.profileKey ? String(parsed.profileKey) : null,
+                    profileName: parsed.profileName ? String(parsed.profileName) : null,
+                    profileType: (0, type_1.normalizeType)(parsed.profileType) || null,
+                    configPath: parsed.configPath ? String(parsed.configPath) : null,
+                    terminalTag: parsed.terminalTag ? String(parsed.terminalTag) : null,
+                    cwd: parsed.cwd ? String(parsed.cwd) : null,
+                    sessionFile: parsed.sessionFile ? String(parsed.sessionFile) : null,
+                    sessionId: parsed.sessionId ? String(parsed.sessionId) : null,
+                });
+            }
+            catch {
+                // ignore invalid lines
+            }
+        }
+    }
+    return entries;
+}
+function readSessionBindingIndex(config, configPath) {
+    const profileLogPath = getProfileLogPath(config, configPath);
+    const entries = readProfileLogEntries([profileLogPath]);
+    const byFile = new Set();
+    const byId = new Set();
+    for (const entry of entries) {
+        if (entry.kind !== "session")
+            continue;
+        if (entry.sessionFile)
+            byFile.add(entry.sessionFile);
+        if (entry.sessionId)
+            byId.add(entry.sessionId);
+    }
+    return { byFile, byId };
+}
+function normalizeProfileMatch(config, entry, type) {
+    const profileKey = entry.profileKey;
+    let profileName = entry.profileName;
+    if (profileKey && config.profiles && config.profiles[profileKey]) {
+        profileName = (0, type_1.getProfileDisplayName)(profileKey, config.profiles[profileKey], type);
+    }
+    if (!profileName && profileKey)
+        profileName = profileKey;
+    return { profileKey, profileName };
+}
+function resolveUniqueProfileMatch(config, entries, type) {
+    const uniqueProfiles = new Map();
+    for (const entry of entries) {
+        const id = entry.profileKey || entry.profileName || "";
+        if (!id)
+            continue;
+        if (!uniqueProfiles.has(id))
+            uniqueProfiles.set(id, entry);
+    }
+    if (uniqueProfiles.size === 0)
+        return { match: null, ambiguous: false };
+    if (uniqueProfiles.size !== 1)
+        return { match: null, ambiguous: true };
+    const best = Array.from(uniqueProfiles.values())[0];
+    return { match: normalizeProfileMatch(config, best, type), ambiguous: false };
+}
+function resolveProfileForSession(config, logEntries, type, sessionFile, sessionId) {
+    const sessionEntries = logEntries.filter((entry) => entry.kind === "session" && entry.profileType === type);
+    if (sessionFile) {
+        const matches = sessionEntries.filter((entry) => entry.sessionFile && entry.sessionFile === sessionFile);
+        if (matches.length > 0) {
+            const resolved = resolveUniqueProfileMatch(config, matches, type);
+            if (resolved.match || resolved.ambiguous)
+                return resolved;
+        }
+    }
+    if (sessionId) {
+        const matches = sessionEntries.filter((entry) => entry.sessionId && entry.sessionId === sessionId);
+        if (matches.length > 0) {
+            const resolved = resolveUniqueProfileMatch(config, matches, type);
+            if (resolved.match || resolved.ambiguous)
+                return resolved;
+        }
+    }
+    return { match: null, ambiguous: false };
+}
+function readUsageState(statePath) {
+    if (!statePath || !fs.existsSync(statePath)) {
+        return { version: 1, files: {}, sessions: {} };
+    }
+    try {
+        const raw = fs.readFileSync(statePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return { version: 1, files: {}, sessions: {} };
+        }
+        const files = parsed.files && typeof parsed.files === "object" ? parsed.files : {};
+        const sessions = parsed.sessions && typeof parsed.sessions === "object" ? parsed.sessions : {};
+        return { version: 1, files, sessions };
+    }
+    catch {
+        return { version: 1, files: {}, sessions: {} };
+    }
+}
+function writeUsageState(statePath, state) {
+    const dir = path.dirname(statePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+function collectSessionFiles(root) {
+    if (!root || !fs.existsSync(root))
+        return [];
+    const files = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith("."))
+                continue;
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                files.push(full);
+            }
+        }
+    }
+    return files;
+}
+function updateMinMaxTs(current, ts) {
+    if (!ts)
+        return;
+    const time = new Date(ts).getTime();
+    if (Number.isNaN(time))
+        return;
+    if (!current.start || new Date(current.start).getTime() > time) {
+        current.start = ts;
+    }
+    if (!current.end || new Date(current.end).getTime() < time) {
+        current.end = ts;
+    }
+}
+function parseCodexSessionFile(filePath) {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const lines = raw.split(/\r?\n/);
+    let maxTotal = 0;
+    let maxInput = 0;
+    let maxOutput = 0;
+    let hasTotal = false;
+    let sumLast = 0;
+    let sumLastInput = 0;
+    let sumLastOutput = 0;
+    const tsRange = { start: null, end: null };
+    let cwd = null;
+    let sessionId = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (!parsed || typeof parsed !== "object")
+                continue;
+            if (parsed.timestamp)
+                updateMinMaxTs(tsRange, String(parsed.timestamp));
+            if (!cwd && parsed.type === "session_meta") {
+                const payload = parsed.payload || {};
+                if (payload && payload.cwd)
+                    cwd = String(payload.cwd);
+                if (!sessionId && payload && payload.id) {
+                    sessionId = String(payload.id);
+                }
+            }
+            if (!cwd && parsed.type === "turn_context") {
+                const payload = parsed.payload || {};
+                if (payload && payload.cwd)
+                    cwd = String(payload.cwd);
+            }
+            if (parsed.type !== "event_msg")
+                continue;
+            const payload = parsed.payload;
+            if (!payload || payload.type !== "token_count")
+                continue;
+            const info = payload.info || {};
+            const totalUsage = info.total_token_usage || {};
+            const lastUsage = info.last_token_usage || {};
+            const totalTokens = Number(totalUsage.total_tokens);
+            if (Number.isFinite(totalTokens)) {
+                hasTotal = true;
+                if (totalTokens > maxTotal)
+                    maxTotal = totalTokens;
+                const totalInput = Number(totalUsage.input_tokens);
+                const totalOutput = Number(totalUsage.output_tokens);
+                if (Number.isFinite(totalInput) && totalInput > maxInput) {
+                    maxInput = totalInput;
+                }
+                if (Number.isFinite(totalOutput) && totalOutput > maxOutput) {
+                    maxOutput = totalOutput;
+                }
+            }
+            else {
+                const lastTokens = Number(lastUsage.total_tokens);
+                if (Number.isFinite(lastTokens))
+                    sumLast += lastTokens;
+                const lastInput = Number(lastUsage.input_tokens);
+                const lastOutput = Number(lastUsage.output_tokens);
+                if (Number.isFinite(lastInput))
+                    sumLastInput += lastInput;
+                if (Number.isFinite(lastOutput))
+                    sumLastOutput += lastOutput;
+            }
+        }
+        catch {
+            // ignore invalid lines
+        }
+    }
+    if (!hasTotal) {
+        maxTotal = sumLast;
+        maxInput = sumLastInput;
+        maxOutput = sumLastOutput;
+    }
+    return {
+        inputTokens: maxInput,
+        outputTokens: maxOutput,
+        totalTokens: maxTotal,
+        startTs: tsRange.start,
+        endTs: tsRange.end,
+        cwd,
+        sessionId,
+    };
+}
+function parseClaudeSessionFile(filePath) {
+    var _a, _b, _c, _d;
+    const raw = fs.readFileSync(filePath, "utf8");
+    const lines = raw.split(/\r?\n/);
+    let totalTokens = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const tsRange = { start: null, end: null };
+    let cwd = null;
+    let sessionId = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (!parsed || typeof parsed !== "object")
+                continue;
+            if (parsed.timestamp)
+                updateMinMaxTs(tsRange, String(parsed.timestamp));
+            if (!cwd && parsed.cwd)
+                cwd = String(parsed.cwd);
+            if (!sessionId && parsed.sessionId) {
+                sessionId = String(parsed.sessionId);
+            }
+            const message = parsed.message;
+            const usage = message && message.usage ? message.usage : null;
+            if (!usage)
+                continue;
+            const input = Number((_a = usage.input_tokens) !== null && _a !== void 0 ? _a : 0);
+            const output = Number((_b = usage.output_tokens) !== null && _b !== void 0 ? _b : 0);
+            const cacheCreate = Number((_c = usage.cache_creation_input_tokens) !== null && _c !== void 0 ? _c : 0);
+            const cacheRead = Number((_d = usage.cache_read_input_tokens) !== null && _d !== void 0 ? _d : 0);
+            if (Number.isFinite(input))
+                inputTokens += input;
+            if (Number.isFinite(output))
+                outputTokens += output;
+            totalTokens +=
+                (Number.isFinite(input) ? input : 0) +
+                    (Number.isFinite(output) ? output : 0) +
+                    (Number.isFinite(cacheCreate) ? cacheCreate : 0) +
+                    (Number.isFinite(cacheRead) ? cacheRead : 0);
+        }
+        catch {
+            // ignore invalid lines
+        }
+    }
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        startTs: tsRange.start,
+        endTs: tsRange.end,
+        cwd,
+        sessionId,
+    };
+}
+const LOCK_STALE_MS = 10 * 60 * 1000;
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err === null || err === void 0 ? void 0 : err.code;
+        return code === "EPERM";
+    }
+}
+function readLockInfo(lockPath) {
+    try {
+        const raw = fs.readFileSync(lockPath, "utf8");
+        const lines = raw.split(/\r?\n/);
+        const pid = Number(lines[0] || "");
+        const ts = lines[1] ? new Date(lines[1]).getTime() : Number.NaN;
+        return {
+            pid: Number.isFinite(pid) && pid > 0 ? pid : null,
+            timestampMs: Number.isFinite(ts) ? ts : null,
+        };
+    }
+    catch {
+        return { pid: null, timestampMs: null };
+    }
+}
+function isLockStale(lockPath) {
+    const info = readLockInfo(lockPath);
+    if (info.pid !== null) {
+        return !isProcessAlive(info.pid);
+    }
+    if (info.timestampMs !== null) {
+        return Date.now() - info.timestampMs > LOCK_STALE_MS;
+    }
+    return true;
+}
+function acquireLock(lockPath) {
+    const dir = path.dirname(lockPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const attemptAcquire = () => {
+        try {
+            const fd = fs.openSync(lockPath, "wx");
+            fs.writeFileSync(fd, `${process.pid}\n${new Date().toISOString()}\n`, "utf8");
+            return fd;
+        }
+        catch (err) {
+            const code = err === null || err === void 0 ? void 0 : err.code;
+            if (code !== "EEXIST")
+                return null;
+        }
+        return null;
+    };
+    const fd = attemptAcquire();
+    if (fd !== null)
+        return fd;
+    if (!isLockStale(lockPath))
+        return null;
+    try {
+        fs.unlinkSync(lockPath);
+    }
+    catch {
+        return null;
+    }
+    return attemptAcquire();
+}
+function releaseLock(lockPath, fd) {
+    if (fd === null)
+        return;
+    try {
+        fs.closeSync(fd);
+    }
+    catch {
+        // ignore
+    }
+    try {
+        fs.unlinkSync(lockPath);
+    }
+    catch {
+        // ignore
+    }
+}
+function appendUsageRecord(usagePath, record) {
+    const dir = path.dirname(usagePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.appendFileSync(usagePath, `${JSON.stringify(record)}\n`, "utf8");
+}
+function readUsageRecords(usagePath) {
+    var _a, _b, _c, _d, _e;
+    if (!usagePath || !fs.existsSync(usagePath))
+        return [];
+    const raw = fs.readFileSync(usagePath, "utf8");
+    const lines = raw.split(/\r?\n/);
+    const records = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (!parsed || typeof parsed !== "object")
+                continue;
+            const input = Number((_a = parsed.inputTokens) !== null && _a !== void 0 ? _a : 0);
+            const output = Number((_b = parsed.outputTokens) !== null && _b !== void 0 ? _b : 0);
+            const total = Number((_c = parsed.totalTokens) !== null && _c !== void 0 ? _c : input + output);
+            const type = (0, type_1.normalizeType)(parsed.type) || String((_d = parsed.type) !== null && _d !== void 0 ? _d : "unknown");
+            records.push({
+                ts: String((_e = parsed.ts) !== null && _e !== void 0 ? _e : ""),
+                type,
+                profileKey: parsed.profileKey ? String(parsed.profileKey) : null,
+                profileName: parsed.profileName ? String(parsed.profileName) : null,
+                inputTokens: Number.isFinite(input) ? input : 0,
+                outputTokens: Number.isFinite(output) ? output : 0,
+                totalTokens: Number.isFinite(total) ? total : 0,
+            });
+        }
+        catch {
+            // ignore invalid lines
+        }
+    }
+    return records;
+}
+function syncUsageFromSessions(config, configPath, usagePath) {
+    const statePath = getUsageStatePath(usagePath, config);
+    const lockPath = `${statePath}.lock`;
+    const lockFd = acquireLock(lockPath);
+    if (lockFd === null)
+        return;
+    try {
+        const profileLogPath = getProfileLogPath(config, configPath);
+        const logEntries = readProfileLogEntries([profileLogPath]);
+        const state = readUsageState(statePath);
+        const files = state.files || {};
+        const sessions = state.sessions || {};
+        const codexFiles = collectSessionFiles(getCodexSessionsPath(config));
+        const claudeFiles = collectSessionFiles(getClaudeSessionsPath(config));
+        const processFile = (filePath, type) => {
+            let stat = null;
+            try {
+                stat = fs.statSync(filePath);
+            }
+            catch {
+                return;
+            }
+            if (!stat || !stat.isFile())
+                return;
+            const prev = files[filePath];
+            if (prev && prev.mtimeMs === stat.mtimeMs && prev.size === stat.size) {
+                return;
+            }
+            let stats;
+            try {
+                stats =
+                    type === "codex"
+                        ? parseCodexSessionFile(filePath)
+                        : parseClaudeSessionFile(filePath);
+            }
+            catch {
+                return;
+            }
+            const resolved = resolveProfileForSession(config, logEntries, type, filePath, stats.sessionId);
+            if (!resolved.match)
+                return;
+            const sessionKey = stats.sessionId ? buildSessionKey(type, stats.sessionId) : null;
+            const sessionPrev = sessionKey ? sessions[sessionKey] : null;
+            const prevInput = prev ? prev.inputTokens : 0;
+            const prevOutput = prev ? prev.outputTokens : 0;
+            const prevTotal = prev ? prev.totalTokens : 0;
+            const prevInputMax = sessionPrev
+                ? Math.max(prevInput, sessionPrev.inputTokens)
+                : prevInput;
+            const prevOutputMax = sessionPrev
+                ? Math.max(prevOutput, sessionPrev.outputTokens)
+                : prevOutput;
+            const prevTotalMax = sessionPrev
+                ? Math.max(prevTotal, sessionPrev.totalTokens)
+                : prevTotal;
+            let deltaInput = stats.inputTokens - prevInputMax;
+            let deltaOutput = stats.outputTokens - prevOutputMax;
+            let deltaTotal = stats.totalTokens - prevTotalMax;
+            if (deltaTotal < 0 || deltaInput < 0 || deltaOutput < 0) {
+                if (sessionPrev) {
+                    deltaInput = 0;
+                    deltaOutput = 0;
+                    deltaTotal = 0;
+                }
+                else {
+                    deltaInput = stats.inputTokens;
+                    deltaOutput = stats.outputTokens;
+                    deltaTotal = stats.totalTokens;
+                }
+            }
+            if (deltaTotal > 0) {
+                const record = {
+                    ts: stats.endTs || stats.startTs || new Date().toISOString(),
+                    type,
+                    profileKey: resolved.match.profileKey,
+                    profileName: resolved.match.profileName,
+                    inputTokens: deltaInput,
+                    outputTokens: deltaOutput,
+                    totalTokens: deltaTotal,
+                };
+                appendUsageRecord(usagePath, record);
+            }
+            if (sessionKey) {
+                const nextInput = sessionPrev
+                    ? Math.max(sessionPrev.inputTokens, stats.inputTokens)
+                    : stats.inputTokens;
+                const nextOutput = sessionPrev
+                    ? Math.max(sessionPrev.outputTokens, stats.outputTokens)
+                    : stats.outputTokens;
+                const nextTotal = sessionPrev
+                    ? Math.max(sessionPrev.totalTokens, stats.totalTokens)
+                    : stats.totalTokens;
+                sessions[sessionKey] = {
+                    type,
+                    inputTokens: nextInput,
+                    outputTokens: nextOutput,
+                    totalTokens: nextTotal,
+                    startTs: sessionPrev ? sessionPrev.startTs : stats.startTs,
+                    endTs: stats.endTs || (sessionPrev ? sessionPrev.endTs : null),
+                    cwd: stats.cwd || (sessionPrev ? sessionPrev.cwd : null),
+                };
+            }
+            files[filePath] = {
+                mtimeMs: stat.mtimeMs,
+                size: stat.size,
+                type,
+                inputTokens: stats.inputTokens,
+                outputTokens: stats.outputTokens,
+                totalTokens: stats.totalTokens,
+                startTs: stats.startTs,
+                endTs: stats.endTs,
+                cwd: stats.cwd,
+            };
+        };
+        for (const filePath of codexFiles)
+            processFile(filePath, "codex");
+        for (const filePath of claudeFiles)
+            processFile(filePath, "claude");
+        state.files = files;
+        state.sessions = sessions;
+        writeUsageState(statePath, state);
+    }
+    finally {
+        releaseLock(lockPath, lockFd);
+    }
+}