@openxiaobu/codexl 0.1.0

package/dist/config.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodexSwHome = getCodexSwHome;
+exports.getConfigPath = getConfigPath;
+exports.getPidPath = getPidPath;
+exports.getServiceLogPath = getServiceLogPath;
+exports.expandHome = expandHome;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.getManagedHome = getManagedHome;
+exports.upsertAccount = upsertAccount;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = __importDefault(require("yaml"));
+const zod_1 = require("zod");
+const managedAccountSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    name: zod_1.z.string().min(1),
+    codex_home: zod_1.z.string().min(1),
+    email: zod_1.z.string().email().optional(),
+    enabled: zod_1.z.boolean().default(true),
+    imported_at: zod_1.z.string().optional()
+});
+const configSchema = zod_1.z.object({
+    version: zod_1.z.number().int().default(1),
+    server: zod_1.z
+        .object({
+        host: zod_1.z.string().default("127.0.0.1"),
+        port: zod_1.z.number().int().default(4389),
+        api_key: zod_1.z.string().default("codexl-defaultkey")
+    })
+        .default({
+        host: "127.0.0.1",
+        port: 4389,
+        api_key: "codexl-defaultkey"
+    }),
+    upstream: zod_1.z
+        .object({
+        codex_base_url: zod_1.z.string().default("https://chatgpt.com/backend-api/codex"),
+        auth_base_url: zod_1.z.string().default("https://auth.openai.com"),
+        oauth_client_id: zod_1.z.string().default("app_EMoamEEZ73f0CkXaXp7hrann")
+    })
+        .default({
+        codex_base_url: "https://chatgpt.com/backend-api/codex",
+        auth_base_url: "https://auth.openai.com",
+        oauth_client_id: "app_EMoamEEZ73f0CkXaXp7hrann"
+    }),
+    accounts: zod_1.z.array(managedAccountSchema).default([])
+});
+/**
+ * 返回 codexl 的根目录，并确保基础目录结构存在。
+ *
+ * @returns codexl 根目录绝对路径。
+ * @throws 当目录无法创建时抛出文件系统错误。
+ */
+function getCodexSwHome() {
+    const home = node_path_1.default.join(node_os_1.default.homedir(), ".codexl");
+    const legacyHome = node_path_1.default.join(node_os_1.default.homedir(), ".codexsw");
+    if (!node_fs_1.default.existsSync(home) && node_fs_1.default.existsSync(legacyHome)) {
+        node_fs_1.default.cpSync(legacyHome, home, { recursive: true });
+    }
+    // 先创建 codexl 根目录，后续命令统一基于该目录读写状态。
+    node_fs_1.default.mkdirSync(home, { recursive: true });
+    node_fs_1.default.mkdirSync(node_path_1.default.join(home, "homes"), { recursive: true });
+    node_fs_1.default.mkdirSync(node_path_1.default.join(home, "logs"), { recursive: true });
+    return home;
+}
+/**
+ * 返回 codexl 配置文件路径。
+ *
+ * @returns 配置文件绝对路径。
+ */
+function getConfigPath() {
+    return node_path_1.default.join(getCodexSwHome(), "config.yaml");
+}
+/**
+ * 返回后台服务 PID 文件路径。
+ *
+ * @returns PID 文件绝对路径。
+ */
+function getPidPath() {
+    return node_path_1.default.join(getCodexSwHome(), "codexl.pid");
+}
+/**
+ * 返回后台服务日志文件路径。
+ *
+ * @returns 日志文件绝对路径。
+ */
+function getServiceLogPath() {
+    return node_path_1.default.join(getCodexSwHome(), "logs", "service.log");
+}
+/**
+ * 将路径中的 `~` 展开为当前用户家目录。
+ *
+ * @param input 原始路径，允许以 `~` 开头。
+ * @returns 展开后的绝对或原始路径。
+ */
+function expandHome(input) {
+    if (input === "~") {
+        return node_os_1.default.homedir();
+    }
+    if (input.startsWith("~/")) {
+        return node_path_1.default.join(node_os_1.default.homedir(), input.slice(2));
+    }
+    return input;
+}
+/**
+ * 读取 codexl 配置；若配置不存在则返回默认配置。
+ *
+ * @returns 经过 schema 校验后的配置对象。
+ * @throws 当配置存在但内容非法时抛出错误。
+ */
+function loadConfig() {
+    const configPath = getConfigPath();
+    const legacyConfigPath = node_path_1.default.join(node_os_1.default.homedir(), ".codexsw", "config.yaml");
+    if (!node_fs_1.default.existsSync(configPath)) {
+        const defaultConfig = {
+            version: 1,
+            server: {
+                host: "127.0.0.1",
+                port: 4389,
+                api_key: "codexl-defaultkey"
+            },
+            upstream: {
+                codex_base_url: "https://chatgpt.com/backend-api/codex",
+                auth_base_url: "https://auth.openai.com",
+                oauth_client_id: "app_EMoamEEZ73f0CkXaXp7hrann"
+            },
+            accounts: []
+        };
+        saveConfig(defaultConfig);
+        return defaultConfig;
+    }
+    const raw = node_fs_1.default.readFileSync(configPath, "utf8");
+    const parsed = raw.trim() ? yaml_1.default.parse(raw) : {};
+    const normalized = configSchema.parse(parsed);
+    let changed = JSON.stringify(parsed) !== JSON.stringify(normalized);
+    if (normalized.accounts.length === 0 &&
+        node_fs_1.default.existsSync(legacyConfigPath)) {
+        const legacyRaw = node_fs_1.default.readFileSync(legacyConfigPath, "utf8");
+        const legacyParsed = legacyRaw.trim() ? yaml_1.default.parse(legacyRaw) : {};
+        const legacyConfig = configSchema.parse(legacyParsed);
+        if (legacyConfig.accounts.length > 0) {
+            normalized.accounts = legacyConfig.accounts;
+            changed = true;
+        }
+    }
+    // 兼容历史默认值，统一迁移到新的简短本地 key。
+    if (normalized.server.api_key === "local-only-key" ||
+        normalized.server.api_key === "codexsw-defaultkey") {
+        normalized.server.api_key = "codexl-defaultkey";
+        changed = true;
+    }
+    // 当旧配置缺少新字段时，将补全后的配置回写，便于用户直接编辑查看。
+    if (changed) {
+        saveConfig(normalized);
+    }
+    return normalized;
+}
+/**
+ * 持久化 codexl 配置文件。
+ *
+ * @param config 待写入的配置对象。
+ * @returns 无返回值。
+ * @throws 当配置写入失败时抛出文件系统错误。
+ */
+function saveConfig(config) {
+    const configPath = getConfigPath();
+    const text = yaml_1.default.stringify(config);
+    node_fs_1.default.writeFileSync(configPath, text, "utf8");
+}
+/**
+ * 根据账号标识生成其独立的 HOME 目录。
+ *
+ * @param accountId 账号标识，仅用于本地目录名。
+ * @returns 该账号对应的 HOME 目录绝对路径。
+ */
+function getManagedHome(accountId) {
+    return node_path_1.default.join(getCodexSwHome(), "homes", accountId);
+}
+/**
+ * 将账号追加到配置中；若已存在相同 id 则覆盖更新。
+ *
+ * @param account 待写入的账号配置。
+ * @returns 更新后的完整配置对象。
+ */
+function upsertAccount(account) {
+    const config = loadConfig();
+    const index = config.accounts.findIndex((item) => item.id === account.id);
+    if (index >= 0) {
+        config.accounts[index] = account;
+    }
+    else {
+        config.accounts.push(account);
+    }
+    saveConfig(config);
+    return config;
+}

package/dist/login.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginManagedAccount = loginManagedAccount;
+const node_child_process_1 = require("node:child_process");
+const account_store_1 = require("./account-store");
+const config_1 = require("./config");
+/**
+ * 使用独立 HOME 目录拉起官方 `codex login`，完成单账号录入。
+ *
+ * @param accountId 本地账号标识。
+ * @returns Promise，成功时返回导入后的 HOME 目录。
+ * @throws 当 `codex login` 执行失败时抛出错误。
+ */
+async function loginManagedAccount(accountId) {
+    const managedHome = (0, config_1.getManagedHome)(accountId);
+    (0, account_store_1.registerManagedAccount)(accountId, managedHome);
+    return await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)("codex", ["login"], {
+            env: {
+                ...process.env,
+                HOME: managedHome
+            },
+            stdio: "inherit"
+        });
+        child.on("exit", (code) => {
+            if (code === 0) {
+                (0, account_store_1.registerManagedAccount)(accountId, managedHome);
+                resolve(managedHome);
+                return;
+            }
+            reject(new Error(`codex login 失败，退出码: ${code ?? "unknown"}`));
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+    });
+}

package/dist/scheduler.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickBestAccount = pickBestAccount;
+exports.listCandidateAccounts = listCandidateAccounts;
+const config_1 = require("./config");
+const status_1 = require("./status");
+function nextResetWeight(resetAt) {
+    if (!resetAt) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    const diff = resetAt * 1000 - Date.now();
+    return diff > 0 ? diff : Number.MAX_SAFE_INTEGER;
+}
+/**
+ * 选择当前最适合激活的账号。
+ *
+ * 业务规则：
+ * 1. 仅在账号启用且存在凭据时参与调度。
+ * 2. 优先选择当前 5 小时和周窗口都未受限的账号。
+ * 3. 在多个可用账号间，优先选择 5 小时剩余额度更高的账号。
+ *
+ * @returns 调度结果；若没有可用账号则返回 `null`。
+ */
+function pickBestAccount() {
+    return listCandidateAccounts()[0] ?? null;
+}
+/**
+ * 返回按优先级排序后的可用账号列表，供代理重试链路使用。
+ *
+ * @returns 候选账号列表，已按优先级从高到低排序。
+ */
+function listCandidateAccounts() {
+    const config = (0, config_1.loadConfig)();
+    const statuses = (0, status_1.collectAccountStatuses)();
+    const accountMap = new Map(config.accounts.map((item) => [item.id, item]));
+    const available = statuses
+        .filter((item) => item.isAvailable)
+        .sort((left, right) => {
+        const fiveHourDiff = (right.fiveHourLeftPercent ?? -1) - (left.fiveHourLeftPercent ?? -1);
+        if (fiveHourDiff !== 0) {
+            return fiveHourDiff;
+        }
+        const weeklyDiff = (right.weeklyLeftPercent ?? -1) - (left.weeklyLeftPercent ?? -1);
+        if (weeklyDiff !== 0) {
+            return weeklyDiff;
+        }
+        return nextResetWeight(left.fiveHourResetsAt) - nextResetWeight(right.fiveHourResetsAt);
+    });
+    return available
+        .map((winner) => {
+        const account = accountMap.get(winner.id);
+        if (!account) {
+            return null;
+        }
+        return {
+            account,
+            status: winner,
+            reason: "优先选择 5 小时窗口剩余额度最高且当前可用的账号"
+        };
+    })
+        .filter((item) => item !== null);
+}

package/dist/serve.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("./config");
+const server_1 = require("./server");
+/**
+ * 后台服务进程入口。
+ *
+ * @returns Promise，无返回值。
+ * @throws 当端口参数非法或服务启动失败时抛出异常。
+ */
+async function main() {
+    const config = (0, config_1.loadConfig)();
+    const portArgIndex = process.argv.findIndex((item) => item === "--port");
+    const port = portArgIndex >= 0 && process.argv[portArgIndex + 1]
+        ? Number(process.argv[portArgIndex + 1])
+        : config.server.port;
+    await (0, server_1.startServer)(port);
+}
+void main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`codexl service 启动失败: ${message}`);
+    process.exit(1);
+});

package/dist/server.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const fastify_1 = __importDefault(require("fastify"));
+const undici_1 = require("undici");
+const account_store_1 = require("./account-store");
+const config_1 = require("./config");
+const status_1 = require("./status");
+const scheduler_1 = require("./scheduler");
+const state_1 = require("./state");
+const usage_sync_1 = require("./usage-sync");
+function getBearerToken(headerValue) {
+    if (!headerValue) {
+        return null;
+    }
+    const match = /^Bearer\s+(.+)$/i.exec(headerValue);
+    return match?.[1] ?? null;
+}
+/**
+ * 根据错误文本与当前账号状态，决定本地禁用时长。
+ *
+ * 业务规则：
+ * 1. 周限制优先，直到周窗口重置时间。
+ * 2. 5 小时额度限制次之，直到 5 小时窗口重置时间。
+ * 3. 未能明确识别时，按 5 分钟临时熔断处理。
+ *
+ * @param picked 当前被选中的账号及状态。
+ * @param errorText 上游返回的错误文本。
+ * @returns 本地禁用窗口与原因。
+ */
+function resolveBlockWindow(picked, errorText) {
+    const lowerText = errorText.toLowerCase();
+    if (lowerText.includes("weekly") ||
+        lowerText.includes("7 day") ||
+        lowerText.includes("7-day") ||
+        picked.status.isWeeklyLimited) {
+        return {
+            until: picked.status.weeklyResetsAt ?? Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60,
+            reason: "weekly_limited"
+        };
+    }
+    if (lowerText.includes("5 hour") ||
+        lowerText.includes("5-hour") ||
+        lowerText.includes("5h") ||
+        lowerText.includes("usage limit") ||
+        picked.status.isFiveHourLimited) {
+        return {
+            until: picked.status.fiveHourResetsAt ?? Math.floor(Date.now() / 1000) + 5 * 60,
+            reason: "five_hour_limited"
+        };
+    }
+    return {
+        until: Math.floor(Date.now() / 1000) + 5 * 60,
+        reason: "temporary_5m_limit"
+    };
+}
+/**
+ * 启动一个极轻量本地服务，供后续接入代理或脚本化查询使用。
+ *
+ * 当前阶段服务用途：
+ * 1. 暴露健康检查。
+ * 2. 暴露账号状态与当前推荐账号。
+ * 3. 为后续真正的 OpenAI-compatible proxy 预留入口。
+ *
+ * @param port 本地监听端口。
+ * @returns Fastify 实例，便于调用方在测试或脚本中复用。
+ * @throws 当端口占用或服务启动失败时抛出异常。
+ */
+async function startServer(port) {
+    const config = (0, config_1.loadConfig)();
+    const app = (0, fastify_1.default)({ logger: false });
+    app.addHook("onRequest", async (request, reply) => {
+        if (request.url === "/health") {
+            return;
+        }
+        const bearer = getBearerToken(request.headers.authorization);
+        if (bearer !== config.server.api_key) {
+            reply.code(401);
+            throw new Error("invalid local api key");
+        }
+    });
+    app.get("/health", async () => {
+        return { ok: true };
+    });
+    app.post("/refresh", async () => {
+        const results = await refreshAccountUsageForBestEffort();
+        return { refreshed: results };
+    });
+    app.get("/accounts", async () => {
+        return {
+            accounts: (0, status_1.collectAccountStatuses)(),
+            selected: (0, scheduler_1.pickBestAccount)()
+        };
+    });
+    const proxyHandler = async (requestMessage, reply) => {
+        const candidates = (0, scheduler_1.listCandidateAccounts)();
+        if (candidates.length === 0) {
+            reply.code(503);
+            reply.send({
+                error: {
+                    message: "当前没有可用账号",
+                    type: "no_available_account"
+                }
+            });
+            return;
+        }
+        let lastErrorPayload = {
+            error: {
+                message: "所有账号都请求失败",
+                type: "all_accounts_failed"
+            }
+        };
+        let lastStatusCode = 503;
+        for (const picked of candidates) {
+            try {
+                await (0, usage_sync_1.refreshAccountUsage)(picked.account.id);
+            }
+            catch {
+                // 刷新失败时继续使用本地缓存，不中断请求链路。
+            }
+            const auth = (0, account_store_1.readAuthFile)(picked.account.codex_home);
+            let accessToken = auth?.tokens?.access_token;
+            const accountIdHeader = auth?.tokens?.account_id;
+            if (!accessToken) {
+                lastErrorPayload = {
+                    error: {
+                        message: `账号 ${picked.account.id} 缺少 access_token`,
+                        type: "invalid_account_auth"
+                    }
+                };
+                lastStatusCode = 503;
+                continue;
+            }
+            const sendUpstream = async () => await (0, undici_1.request)(`${config.upstream.codex_base_url}/responses`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${accessToken}`,
+                    accept: "text/event-stream, application/json",
+                    "content-type": "application/json",
+                    "user-agent": "codexl/0.1.0",
+                    ...(accountIdHeader ? { "chatgpt-account-id": accountIdHeader } : {})
+                },
+                body: JSON.stringify(requestMessage)
+            });
+            let upstream = await sendUpstream();
+            if (upstream.statusCode === 401) {
+                const refreshed = await (0, usage_sync_1.refreshAccountTokens)(picked.account.id);
+                accessToken = refreshed.tokens?.access_token ?? accessToken;
+                upstream = await sendUpstream();
+            }
+            if (upstream.statusCode === 429 || upstream.statusCode === 403) {
+                const errorText = await upstream.body.text();
+                const block = resolveBlockWindow(picked, errorText);
+                (0, state_1.setAccountBlock)(picked.account.id, block.until, block.reason);
+                lastStatusCode = upstream.statusCode;
+                lastErrorPayload = {
+                    error: {
+                        message: `账号 ${picked.account.id} 受限: ${errorText}`,
+                        type: "account_rate_limited"
+                    }
+                };
+                continue;
+            }
+            if (upstream.statusCode >= 400) {
+                const errorText = await upstream.body.text();
+                const lowerText = errorText.toLowerCase();
+                if (lowerText.includes("usage limit") || lowerText.includes("try again later")) {
+                    const block = resolveBlockWindow(picked, errorText);
+                    (0, state_1.setAccountBlock)(picked.account.id, block.until, block.reason);
+                    lastStatusCode = upstream.statusCode;
+                    lastErrorPayload = {
+                        error: {
+                            message: `账号 ${picked.account.id} 命中额度限制: ${errorText}`,
+                            type: "account_usage_limited"
+                        }
+                    };
+                    continue;
+                }
+                reply.raw.writeHead(upstream.statusCode, {
+                    "content-type": "application/json"
+                });
+                reply.raw.end(errorText);
+                return;
+            }
+            const headers = {};
+            const contentType = upstream.headers["content-type"];
+            const cacheControl = upstream.headers["cache-control"];
+            if (typeof contentType === "string") {
+                headers["content-type"] = contentType;
+            }
+            if (typeof cacheControl === "string") {
+                headers["cache-control"] = cacheControl;
+            }
+            headers.connection = "keep-alive";
+            reply.raw.writeHead(upstream.statusCode, headers);
+            for await (const chunk of upstream.body) {
+                reply.raw.write(chunk);
+            }
+            reply.raw.end();
+            return;
+        }
+        reply.code(lastStatusCode);
+        reply.send(lastErrorPayload);
+    };
+    app.post("/v1/responses", async (request, reply) => {
+        await proxyHandler(request.body, reply);
+    });
+    app.post("/backend-api/codex/responses", async (request, reply) => {
+        await proxyHandler(request.body, reply);
+    });
+    await app.listen({
+        host: config.server.host,
+        port: Number.isFinite(port) ? port : config.server.port
+    });
+}
+async function refreshAccountUsageForBestEffort() {
+    const statuses = (0, status_1.collectAccountStatuses)();
+    const refreshed = [];
+    for (const status of statuses) {
+        try {
+            const item = await (0, usage_sync_1.refreshAccountUsage)(status.id);
+            refreshed.push(item);
+        }
+        catch (error) {
+            refreshed.push({
+                accountId: status.id,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    return refreshed;
+}

package/dist/state.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadState = loadState;
+exports.saveState = saveState;
+exports.setAccountBlock = setAccountBlock;
+exports.pruneExpiredBlocks = pruneExpiredBlocks;
+exports.getAccountBlock = getAccountBlock;
+exports.setUsageCache = setUsageCache;
+exports.getUsageCache = getUsageCache;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("./config");
+function getStatePath() {
+    return node_path_1.default.join((0, config_1.getCodexSwHome)(), "state.json");
+}
+/**
+ * 读取 codexl 的本地运行状态；文件不存在时返回默认空状态。
+ *
+ * @returns 当前持久化状态。
+ */
+function loadState() {
+    const statePath = getStatePath();
+    if (!node_fs_1.default.existsSync(statePath)) {
+        return {
+            account_blocks: {},
+            usage_cache: {}
+        };
+    }
+    const raw = node_fs_1.default.readFileSync(statePath, "utf8");
+    const parsed = raw.trim()
+        ? JSON.parse(raw)
+        : {
+            account_blocks: {},
+            usage_cache: {}
+        };
+    return {
+        account_blocks: parsed.account_blocks ?? {},
+        usage_cache: parsed.usage_cache ?? {}
+    };
+}
+/**
+ * 持久化 codexl 的本地运行状态。
+ *
+ * @param state 待写入状态对象。
+ * @returns 无返回值。
+ */
+function saveState(state) {
+    const statePath = getStatePath();
+    node_fs_1.default.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+/**
+ * 为指定账号设置本地禁用窗口，用于临时熔断或周限制冷却。
+ *
+ * @param accountId 账号标识。
+ * @param until 禁用截止时间，Unix 秒时间戳；为 `null` 时表示仅记录原因。
+ * @param reason 禁用原因。
+ * @returns 无返回值。
+ */
+function setAccountBlock(accountId, until, reason) {
+    const state = loadState();
+    state.account_blocks[accountId] = {
+        until,
+        reason,
+        updated_at: new Date().toISOString()
+    };
+    saveState(state);
+}
+/**
+ * 清理已过期的账号禁用记录，并返回最新状态。
+ *
+ * @returns 清理后的状态对象。
+ */
+function pruneExpiredBlocks() {
+    const state = loadState();
+    const now = Math.floor(Date.now() / 1000);
+    let changed = false;
+    for (const [accountId, block] of Object.entries(state.account_blocks)) {
+        if (block.until !== null && block.until <= now) {
+            delete state.account_blocks[accountId];
+            changed = true;
+        }
+    }
+    if (changed) {
+        saveState(state);
+    }
+    return state;
+}
+/**
+ * 读取指定账号当前的本地禁用状态；若已过期会自动清理。
+ *
+ * @param accountId 账号标识。
+ * @returns 账号禁用状态；不存在或已过期时返回 `null`。
+ */
+function getAccountBlock(accountId) {
+    const state = pruneExpiredBlocks();
+    return state.account_blocks[accountId] ?? null;
+}
+/**
+ * 更新指定账号的最新额度缓存，仅写入 codexl 自己的状态文件。
+ *
+ * @param usage 最新额度结果。
+ * @returns 无返回值。
+ */
+function setUsageCache(usage) {
+    const state = loadState();
+    state.usage_cache[usage.accountId] = usage;
+    saveState(state);
+}
+/**
+ * 读取指定账号最近一次成功刷新的额度缓存。
+ *
+ * @param accountId 账号标识。
+ * @returns 最新额度缓存；不存在时返回 `null`。
+ */
+function getUsageCache(accountId) {
+    const state = loadState();
+    return state.usage_cache[accountId] ?? null;
+}