chatccc 0.2.279 → 0.2.280

package/README.md

@@ -430,7 +430,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/cd` | 查看或设置后续新建会话的默认工作目录，不改变当前会话；飞书私聊自身始终使用系统用户目录 |
 | `/sessions` | 查看所有会话状态 |
 | `/session <数字>` | 将当前群聊切换到 `/sessions` 列表中的指定会话；飞书私聊不支持切换 |
-| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/7天窗口，Cursor 显示当前周期用量，CCC Agent 和 DSH 仅在官方 DeepSeek 端点时显示账户余额（其他兼容端点自动跳过） |
+| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/7天窗口，主动重置次数查询失败时会明确展示上次成功快照及其查询时间（缓存结果不提供重置按钮）；Cursor 显示当前周期用量，CCC Agent 和 DSH 仅在官方 DeepSeek 端点时显示账户余额（其他兼容端点自动跳过） |
 | `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
 | `/abd<内容>` | 去掉 `/abd` 前缀后把内容发给 Agent，并在消息末尾追加第一性原理需求澄清提示 |
 | `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |

package/dist/src/codex-reset-credits-cache.js

@@ -0,0 +1,105 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { USER_DATA_DIR } from "./config.js";
+const CACHE_FILE = join(USER_DATA_DIR, "state", "codex-reset-credits.json");
+let mutationQueue = Promise.resolve();
+export function codexResetCreditsAccountKey(accountId, accessToken) {
+    if (accountId?.trim())
+        return `account:${accountId.trim()}`;
+    const digest = createHash("sha256").update(accessToken).digest("hex").slice(0, 24);
+    return `token-sha256:${digest}`;
+}
+function emptyCache() {
+    return { version: 1, accounts: {} };
+}
+function normalizeSnapshot(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const value = raw;
+    const availableCount = Number(value.availableCount);
+    if (!Number.isFinite(availableCount) || typeof value.queriedAt !== "string" || !value.queriedAt.trim())
+        return null;
+    const credits = Array.isArray(value.credits)
+        ? value.credits.flatMap((credit) => {
+            if (!credit || typeof credit !== "object")
+                return [];
+            const item = credit;
+            if (typeof item.expiresAt !== "string" || !item.expiresAt.trim())
+                return [];
+            return [{
+                    grantedAt: typeof item.grantedAt === "string" && item.grantedAt.trim() ? item.grantedAt : null,
+                    expiresAt: item.expiresAt,
+                }];
+        })
+        : [];
+    return {
+        availableCount: Math.max(0, Math.trunc(availableCount)),
+        credits,
+        queriedAt: value.queriedAt,
+        locallyAdjusted: value.locallyAdjusted === true,
+    };
+}
+async function readCache() {
+    try {
+        const parsed = JSON.parse(await readFile(CACHE_FILE, "utf-8"));
+        const accounts = {};
+        if (parsed.accounts && typeof parsed.accounts === "object") {
+            for (const [key, raw] of Object.entries(parsed.accounts)) {
+                const snapshot = normalizeSnapshot(raw);
+                if (snapshot)
+                    accounts[key] = snapshot;
+            }
+        }
+        return { version: 1, accounts };
+    }
+    catch {
+        return emptyCache();
+    }
+}
+async function writeCache(cache) {
+    await mkdir(dirname(CACHE_FILE), { recursive: true });
+    const tempFile = `${CACHE_FILE}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tempFile, JSON.stringify(cache, null, 2), "utf-8");
+    try {
+        await rename(tempFile, CACHE_FILE);
+    }
+    catch {
+        await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+        await rm(tempFile, { force: true }).catch(() => { });
+    }
+}
+async function mutateCache(mutate) {
+    const operation = mutationQueue.then(async () => {
+        const cache = await readCache();
+        mutate(cache);
+        await writeCache(cache);
+    });
+    mutationQueue = operation.catch(() => { });
+    return operation;
+}
+export async function readCodexResetCreditsSnapshot(accountKey) {
+    return (await readCache()).accounts[accountKey] ?? null;
+}
+export async function saveCodexResetCreditsSnapshot(accountKey, snapshot) {
+    await mutateCache((cache) => {
+        cache.accounts[accountKey] = {
+            ...snapshot,
+            availableCount: Math.max(0, Math.trunc(snapshot.availableCount)),
+            locallyAdjusted: false,
+        };
+    });
+}
+export async function decrementCachedCodexResetCredits(accountKey) {
+    await mutateCache((cache) => {
+        const current = cache.accounts[accountKey];
+        if (!current)
+            return;
+        cache.accounts[accountKey] = {
+            ...current,
+            availableCount: Math.max(0, current.availableCount - 1),
+            credits: current.credits.slice(1),
+            locallyAdjusted: true,
+        };
+    });
+}

package/dist/src/feishu-api.js

@@ -6,6 +6,7 @@ import sharp from "sharp";
 import { APP_ID, APP_SECRET, BASE_URL, CHAT_LOGS_DIR, PROJECT_ROOT, USER_DATA_DIR, CLAUDE_SESSION_PREFIX, CURSOR_SESSION_PREFIX, CODEX_SESSION_PREFIX, CCC_SESSION_PREFIX, DSH_SESSION_PREFIX, ts, resolveDefaultAgentTool, toolDisplayName, config, } from "./config.js";
 import { getCursorUsageSummary } from "./cursor-usage.js";
 import { applyPrivacy } from "./privacy.js";
+import { codexResetCreditsAccountKey, decrementCachedCodexResetCredits, readCodexResetCreditsSnapshot, saveCodexResetCreditsSnapshot, } from "./codex-reset-credits-cache.js";
 import { buildHelpCard } from "./cards.js";
 // ---------------------------------------------------------------------------
 // Auth
@@ -366,9 +367,6 @@ async function getCodexAuth() {
         return null;
     }
 }
-async function getCodexAccessToken() {
-    return (await getCodexAuth())?.accessToken ?? null;
-}
 function codexAuthHeaders(auth) {
     const headers = {
         Authorization: `Bearer ${auth.accessToken}`,
@@ -399,26 +397,42 @@ function parseCodexResetCreditDetails(data) {
         }),
     };
 }
+const codexResetCreditsInFlight = new Map();
 async function fetchCodexRateLimitResetCredits(auth) {
-    try {
-        const resp = await fetch(CODEX_RESET_CREDITS_URL, {
-            headers: codexAuthHeaders(auth),
-        });
-        const text = await resp.text();
-        if (!resp.ok)
-            throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
-        return parseCodexResetCreditDetails(JSON.parse(text));
-    }
-    catch (err) {
-        console.warn(`[Codex] reset credits lookup failed: ${err.message}`);
-        return null;
-    }
+    const accountKey = codexResetCreditsAccountKey(auth.accountId, auth.accessToken);
+    const existing = codexResetCreditsInFlight.get(accountKey);
+    if (existing)
+        return existing;
+    const lookup = (async () => {
+        try {
+            const resp = await fetch(CODEX_RESET_CREDITS_URL, {
+                headers: codexAuthHeaders(auth),
+            });
+            const text = await resp.text();
+            if (!resp.ok)
+                throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
+            return {
+                details: parseCodexResetCreditDetails(JSON.parse(text)),
+                error: null,
+            };
+        }
+        catch (err) {
+            const error = err.message;
+            console.warn(`[Codex] reset credits lookup failed: ${error}`);
+            return { details: null, error };
+        }
+    })().finally(() => {
+        codexResetCreditsInFlight.delete(accountKey);
+    });
+    codexResetCreditsInFlight.set(accountKey, lookup);
+    return lookup;
 }
-export async function getCodexUsageSummary() {
+export async function getCodexUsageSummary(options = {}) {
     const auth = await getCodexAuth();
     if (!auth)
         throw new Error("missing ~/.codex/auth.json access token");
-    const resetCreditsPromise = fetchCodexRateLimitResetCredits(auth);
+    const includeResetCredits = options.includeResetCredits !== false;
+    const resetCreditsPromise = includeResetCredits ? fetchCodexRateLimitResetCredits(auth) : null;
     const resp = await fetch(CODEX_USAGE_URL, {
         headers: { Authorization: `Bearer ${auth.accessToken}` },
     });
@@ -443,24 +457,77 @@ export async function getCodexUsageSummary() {
         ?? (primaryWindow?.limitWindowSeconds === undefined ? primaryWindow : null);
     const weekly = windows.find((window) => isUsageWindowDuration(window, SEVEN_DAY_WINDOW_SECONDS))
         ?? (secondaryWindow?.limitWindowSeconds === undefined ? secondaryWindow : null);
-    const resetCredits = await resetCreditsPromise;
+    if (!includeResetCredits) {
+        return {
+            fiveHour,
+            weekly,
+            rateLimitResetCreditsAvailable: null,
+            rateLimitResetCredits: null,
+            rateLimitResetCreditsSource: "not_requested",
+            rateLimitResetCreditsQueriedAt: null,
+            rateLimitResetCreditsLocallyAdjusted: false,
+            rateLimitResetCreditsError: null,
+        };
+    }
+    const accountKey = codexResetCreditsAccountKey(auth.accountId, auth.accessToken);
+    const resetLookup = await resetCreditsPromise;
+    const embeddedAvailableCount = parseRateLimitResetCredits(data);
+    const liveAvailableCount = resetLookup.details?.availableCount ?? embeddedAvailableCount;
+    if (liveAvailableCount !== null) {
+        const queriedAt = new Date().toISOString();
+        const liveCredits = resetLookup.details?.availableCredits ?? [];
+        await saveCodexResetCreditsSnapshot(accountKey, {
+            availableCount: liveAvailableCount,
+            credits: liveCredits,
+            queriedAt,
+        }).catch((err) => {
+            console.warn(`[Codex] reset credits snapshot write failed: ${err.message}`);
+        });
+        return {
+            fiveHour,
+            weekly,
+            rateLimitResetCreditsAvailable: liveAvailableCount,
+            rateLimitResetCredits: liveCredits,
+            rateLimitResetCreditsSource: "live",
+            rateLimitResetCreditsQueriedAt: queriedAt,
+            rateLimitResetCreditsLocallyAdjusted: false,
+            rateLimitResetCreditsError: null,
+        };
+    }
+    const cached = await readCodexResetCreditsSnapshot(accountKey);
+    if (cached) {
+        return {
+            fiveHour,
+            weekly,
+            rateLimitResetCreditsAvailable: cached.availableCount,
+            rateLimitResetCredits: cached.credits,
+            rateLimitResetCreditsSource: "cache",
+            rateLimitResetCreditsQueriedAt: cached.queriedAt,
+            rateLimitResetCreditsLocallyAdjusted: cached.locallyAdjusted,
+            rateLimitResetCreditsError: resetLookup.error ?? "OpenAI returned no reset-credit data",
+        };
+    }
     return {
         fiveHour,
         weekly,
-        rateLimitResetCreditsAvailable: resetCredits?.availableCount ?? parseRateLimitResetCredits(data),
-        rateLimitResetCredits: resetCredits?.availableCredits ?? null,
+        rateLimitResetCreditsAvailable: null,
+        rateLimitResetCredits: null,
+        rateLimitResetCreditsSource: "unavailable",
+        rateLimitResetCreditsQueriedAt: null,
+        rateLimitResetCreditsLocallyAdjusted: false,
+        rateLimitResetCreditsError: resetLookup.error ?? "OpenAI returned no reset-credit data",
     };
 }
 export async function consumeCodexRateLimitResetCredit(redeemRequestId) {
     if (!redeemRequestId.trim())
         throw new Error("missing redeem_request_id");
-    const token = await getCodexAccessToken();
-    if (!token)
+    const auth = await getCodexAuth();
+    if (!auth)
         throw new Error("missing ~/.codex/auth.json access token");
     const resp = await fetch(CODEX_RESET_CONSUME_URL, {
         method: "POST",
         headers: {
-            Authorization: `Bearer ${token}`,
+            Authorization: `Bearer ${auth.accessToken}`,
             "Content-Type": "application/json",
         },
         body: JSON.stringify({ redeem_request_id: redeemRequestId }),
@@ -477,10 +544,17 @@ export async function consumeCodexRateLimitResetCredit(redeemRequestId) {
         throw new Error("missing or unknown reset result code");
     }
     const windowsReset = Number(data.windows_reset);
-    return {
+    const result = {
         code,
         windowsReset: Number.isFinite(windowsReset) ? Math.max(0, Math.trunc(windowsReset)) : 0,
     };
+    if (result.code === "reset") {
+        const accountKey = codexResetCreditsAccountKey(auth.accountId, auth.accessToken);
+        await decrementCachedCodexResetCredits(accountKey).catch((err) => {
+            console.warn(`[Codex] reset credits snapshot update failed: ${err.message}`);
+        });
+    }
+    return result;
 }
 async function resolveCodexAvatarUsage(usageHint) {
     if (usageHint !== undefined) {
@@ -489,7 +563,7 @@ async function resolveCodexAvatarUsage(usageHint) {
         return usageHint;
     }
     try {
-        const summary = await getCodexUsageSummary();
+        const summary = await getCodexUsageSummary({ includeResetCredits: false });
         if (!summary.weekly)
             throw new Error("missing weekly usage window");
         return summary;

package/dist/src/orchestrator.js

@@ -100,33 +100,69 @@ function formatCodexUsageSummary(usage, chatGptSubscription = null) {
         ].join("\n");
     };
     const formatResetCredits = () => {
+        const formatDateTime = (value) => {
+            const date = new Date(value);
+            if (!Number.isFinite(date.getTime()))
+                return value;
+            const pad = (part) => String(part).padStart(2, "0");
+            return [
+                date.getFullYear(),
+                "-",
+                pad(date.getMonth() + 1),
+                "-",
+                pad(date.getDate()),
+                " ",
+                pad(date.getHours()),
+                ":",
+                pad(date.getMinutes()),
+                ":",
+                pad(date.getSeconds()),
+            ].join("");
+        };
+        const failureReason = () => {
+            const raw = usage.rateLimitResetCreditsError?.replace(/\s+/g, " ").trim();
+            if (!raw)
+                return "OpenAI 未返回主动重置数据";
+            if (/HTTP 429/i.test(raw))
+                return "OpenAI 返回 HTTP 429（请求受限）";
+            if (/HTTP 404/i.test(raw))
+                return "OpenAI 返回 HTTP 404（接口暂不可用）";
+            return raw.length > 180 ? `${raw.slice(0, 180)}...` : raw;
+        };
+        const source = usage.rateLimitResetCreditsSource ?? "live";
+        if (source === "unavailable") {
+            return [
+                `**主动重置:** 本次查询失败（${failureReason()}）`,
+                "- 没有可用的历史缓存结果",
+            ].join("\n");
+        }
+        if (source === "cache") {
+            const lines = [
+                `**主动重置:** 本次查询失败（${failureReason()}）`,
+                `**上次缓存结果:** 剩余 ${usage.rateLimitResetCreditsAvailable ?? 0} 次`,
+            ];
+            if (usage.rateLimitResetCreditsQueriedAt) {
+                lines.push(`- 查询时间: ${formatDateTime(usage.rateLimitResetCreditsQueriedAt)}`);
+            }
+            if (usage.rateLimitResetCreditsLocallyAdjusted) {
+                lines.push("- 状态: 本地推算，待下次查询确认");
+            }
+            const credits = usage.rateLimitResetCredits ?? [];
+            if (credits.length > 0) {
+                lines.push("**缓存中的过期时间:**");
+                for (const credit of credits)
+                    lines.push(`- ${formatDateTime(credit.expiresAt)}`);
+            }
+            return lines.join("\n");
+        }
         if (usage.rateLimitResetCreditsAvailable === null)
             return "**主动重置:** 暂无数据";
         const lines = [`**主动重置:** 剩余 ${usage.rateLimitResetCreditsAvailable} 次`];
         const credits = usage.rateLimitResetCredits ?? [];
         if (credits.length > 0) {
-            const pad = (value) => String(value).padStart(2, "0");
-            const formatExpiresAt = (value) => {
-                const date = new Date(value);
-                if (!Number.isFinite(date.getTime()))
-                    return value;
-                return [
-                    date.getFullYear(),
-                    "-",
-                    pad(date.getMonth() + 1),
-                    "-",
-                    pad(date.getDate()),
-                    " ",
-                    pad(date.getHours()),
-                    ":",
-                    pad(date.getMinutes()),
-                    ":",
-                    pad(date.getSeconds()),
-                ].join("");
-            };
             lines.push("**过期时间:**");
             for (const credit of credits) {
-                lines.push(`- ${formatExpiresAt(credit.expiresAt)}`);
+                lines.push(`- ${formatDateTime(credit.expiresAt)}`);
             }
         }
         return lines.join("\n");
@@ -397,7 +433,11 @@ async function sendUsageSummary(platform, chatId, tool, avatarStatus = "idle", s
         await platform.sendText(chatId, content).catch(() => { });
     }
     else if (platform.kind === "feishu") {
-        await platform.sendRawCard(chatId, buildCodexUsageCard(content, usage.rateLimitResetCreditsAvailable));
+        const liveResetCredits = usage.rateLimitResetCreditsSource === undefined
+            || usage.rateLimitResetCreditsSource === "live"
+            ? usage.rateLimitResetCreditsAvailable
+            : null;
+        await platform.sendRawCard(chatId, buildCodexUsageCard(content, liveResetCredits));
     }
     else {
         await platform.sendCard(chatId, "Codex Usage", content, "blue");

package/dist/src/sim-platform.js

@@ -105,6 +105,10 @@ export const SimulatedPlatform = {
             weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
             rateLimitResetCreditsAvailable: null,
             rateLimitResetCredits: null,
+            rateLimitResetCreditsSource: "unavailable",
+            rateLimitResetCreditsQueriedAt: null,
+            rateLimitResetCreditsLocallyAdjusted: false,
+            rateLimitResetCreditsError: "Simulated platform has no reset-credit data",
         };
     },
     async consumeCodexRateLimitResetCredit(_redeemRequestId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.279",
+  "version": "0.2.280",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",