@openxiaobu/codexl 0.1.5 → 0.1.7

package/README.md

@@ -8,10 +8,10 @@
 
 - Reuse the official `~/.codex` login state
 - Manage multiple accounts or workspaces as separate slots
-- Fetch the latest usage from the official usage endpoint
+- Refresh and cache the latest usage from the official usage endpoint
 - Expose a local provider endpoint for Codex
 - Apply local block rules for temporary, 5-hour, and weekly limits
-- Automatically switch `~/.codex/config.toml` to the `codexl` provider while the local proxy is running
+- Automatically switch `~/.codex/config.toml` to the `codexl` provider while the local proxy is running (and restore it on stop)
 
 ## Installation
 
@@ -44,6 +44,21 @@ Check latest usage:
 codexl status
 ```
 
+By default, `status` will:
+
+- Refresh usage for all managed accounts
+- Render a compact table with:
+  - Remaining 5-hour / weekly quotas
+  - Reset times
+  - A status column with local block reasons and countdowns (for example: `5h_limited(2h27m)`)
+- Enter an interactive mode where you can toggle `enabled` for any account by `NAME`
+
+If you only want a non-interactive snapshot of the current state:
+
+```bash
+codexl status --no-interactive
+```
+
 Start the local proxy:
 
 ```bash
@@ -81,24 +96,21 @@ Instead it:
 
 ## Managed Codex Config
 
-`codexl start` writes a managed provider block like this:
+`codexl start` writes or updates a provider block like this, based on the current `~/.codexl/config.yaml`:
 
 ```toml
-# >>> codexl managed start >>>
 [model_providers.codexl]
 name = "codexl"
 base_url = "http://127.0.0.1:4389/v1"
 http_headers = { Authorization = "Bearer codexl-defaultkey" }
 wire_api = "responses"
-# <<< codexl managed end <<<
 ```
 
 Behavior:
 
-- If `[model_providers.codexl]` already exists, it is replaced
-- If global `model_provider` exists, it is changed to `codexl`
-- If commented `# model_provider = ...` exists, it is reopened as `model_provider = "codexl"`
-- Global `model` is kept unchanged
+- If global `model_provider` or `# model_provider = ...` exists, it is normalized to `model_provider = "codexl"`
+- If `[model_providers.codexl]` already exists, only that provider block is replaced with the fresh one above
+- Other providers and settings in `config.toml` are left untouched
 - If you start with `--port`, the port is saved to `~/.codexl/config.yaml`
 - `codexl stop` comments out the active `model_provider = "codexl"` line and keeps the rest of the file unchanged
 

package/dist/cli.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
+const node_readline_1 = __importDefault(require("node:readline"));
 const commander_1 = require("commander");
 const account_store_1 = require("./account-store");
 const config_1 = require("./config");
@@ -39,7 +40,7 @@ function getCliVersion() {
  *
  * @returns Promise，无返回值。
  */
-async function handleStatus() {
+async function handleStatus(options) {
     await (0, usage_sync_1.refreshAllAccountUsage)();
     const statuses = (0, status_1.collectAccountStatuses)();
     console.log((0, status_1.renderStatusTable)(statuses));
@@ -48,6 +49,47 @@ async function handleStatus() {
     const weeklyLimited = statuses.filter((item) => item.isWeeklyLimited).length;
     console.log("");
     console.log(`available=${available} 5h_limited=${fiveHourLimited} weekly_limited=${weeklyLimited}`);
+    const interactive = options?.interactive ?? true;
+    if (interactive) {
+        await handleInteractiveToggle();
+    }
+}
+async function handleInteractiveToggle() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.log("当前环境不支持交互式操作，请直接编辑配置文件或使用 --no-interactive 选项。");
+        return;
+    }
+    const rl = node_readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const ask = (question) => new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer));
+    });
+    try {
+        // 允许连续切换多个账号，回车空行退出。
+        // 这里使用账号 NAME 作为标识，与 status 表格中的首列一致。
+        for (;;) {
+            const name = (await ask("输入要切换启用状态的账号 NAME（直接回车退出）：")).trim();
+            if (!name) {
+                break;
+            }
+            const config = (0, config_1.loadConfig)();
+            const index = config.accounts.findIndex((item) => item.name === name);
+            if (index < 0) {
+                console.log(`未找到 NAME 为 "${name}" 的账号，请检查后重试。`);
+                continue;
+            }
+            const account = config.accounts[index];
+            account.enabled = !account.enabled;
+            config.accounts[index] = account;
+            (0, config_1.saveConfig)(config);
+            console.log(`账号 ${account.name} 已${account.enabled ? "启用" : "禁用"}（id=${account.id}，source=${account.codex_home}）。`);
+        }
+    }
+    finally {
+        rl.close();
+    }
 }
 /**
  * 将已有的 Codex HOME 目录中的登录态复制到 codexl 自己的隔离目录并纳入管理。
@@ -175,6 +217,15 @@ function handleStop() {
 function escapeRegExp(input) {
     return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function ensureParentDir(filePath) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+}
+function writeFileAtomic(targetFile, content) {
+    ensureParentDir(targetFile);
+    const tmpFile = `${targetFile}.tmp-${process.pid}-${Date.now()}`;
+    node_fs_1.default.writeFileSync(tmpFile, content, "utf8");
+    node_fs_1.default.renameSync(tmpFile, targetFile);
+}
 /**
  * 返回默认的 `codex config.toml` 路径。
  *
@@ -184,22 +235,18 @@ function getDefaultCodexConfigPath() {
     return node_path_1.default.join(process.env.HOME ?? "", ".codex", "config.toml");
 }
 /**
- * 生成 codexl 托管的 provider 配置块。
+ * 生成 codexl provider 配置块。
  *
  * @returns 可直接写入 `config.toml` 的配置块内容。
  */
 function buildManagedConfigBlock() {
     const config = (0, config_1.loadConfig)();
-    const startMarker = "# >>> codexl managed start >>>";
-    const endMarker = "# <<< codexl managed end <<<";
     return [
-        startMarker,
         "[model_providers.codexl]",
         'name = "codexl"',
         `base_url = "http://${config.server.host}:${config.server.port}/v1"`,
         `http_headers = { Authorization = "Bearer ${config.server.api_key}" }`,
-        'wire_api = "responses"',
-        endMarker
+        'wire_api = "responses"'
     ].join("\n");
 }
 /**
@@ -211,73 +258,71 @@ function buildManagedConfigBlock() {
 function applyManagedCodexConfig(targetPathOrDir, options) {
     const rawTarget = targetPathOrDir ? (0, config_1.expandHome)(targetPathOrDir) : getDefaultCodexConfigPath();
     const targetFile = rawTarget.endsWith(".toml") ? rawTarget : node_path_1.default.join(rawTarget, "config.toml");
-    const startMarker = "# >>> codexl managed start >>>";
-    const endMarker = "# <<< codexl managed end <<<";
     const block = buildManagedConfigBlock();
     let original = "";
     if (node_fs_1.default.existsSync(targetFile)) {
         original = node_fs_1.default.readFileSync(targetFile, "utf8");
     }
-    else {
-        node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetFile), { recursive: true });
-    }
-    const managedBlockPattern = new RegExp(`${escapeRegExp(startMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}\\n?`, "g");
-    const lines = original.replace(managedBlockPattern, "").split(/\r?\n/);
-    let insertAfterIndex = -1;
-    let hasGlobalModelProvider = false;
+    // 更稳定的策略：仅按 provider 名称和 model_provider 改动，不引入额外的 marker。
+    const lines = original.length > 0 ? original.split(/\r?\n/) : [];
+    let replacedModelProvider = false;
+    const modelProviderLine = 'model_provider = "codexl"';
     for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        const trimmed = line.trim();
-        if (/^#\s*model_provider\s*=/.test(trimmed)) {
-            lines[i] = 'model_provider = "codexl"';
-            hasGlobalModelProvider = true;
+        const trimmed = lines[i].trim();
+        // 优先替换被注释掉的默认行（只替换第一处，减少对用户文件的干扰）。
+        if (!replacedModelProvider && /^#\s*model_provider\s*=/.test(trimmed)) {
+            lines[i] = modelProviderLine;
+            replacedModelProvider = true;
             continue;
         }
-        if (trimmed.startsWith("#")) {
+        // 替换真实生效的 model_provider 行。
+        if (/^model_provider\s*=/.test(trimmed) && !trimmed.startsWith("#")) {
+            lines[i] = modelProviderLine;
+            replacedModelProvider = true;
             continue;
         }
-        if (/^model_provider\s*=/.test(trimmed)) {
-            lines[i] = 'model_provider = "codexl"';
-            hasGlobalModelProvider = true;
-            continue;
+    }
+    if (!replacedModelProvider) {
+        const firstNonEmptyIndex = lines.findIndex((line) => line.trim() !== "");
+        if (firstNonEmptyIndex >= 0) {
+            lines.splice(firstNonEmptyIndex, 0, modelProviderLine, "");
         }
+        else {
+            lines.push(modelProviderLine, "");
+        }
+    }
+    // 替换或追加 [model_providers.codexl] 这一段配置。
+    const blockLines = block.split("\n");
+    let insertAfterIndex = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        const trimmed = lines[i].trim();
         if (trimmed === "[model_providers.codexl]") {
             let j = i;
             while (j < lines.length) {
-                const current = lines[j];
-                const currentTrimmed = current.trim();
+                const currentTrimmed = lines[j].trim();
                 if (j > i && currentTrimmed.startsWith("[") && !currentTrimmed.startsWith("[[")) {
                     break;
                 }
                 insertAfterIndex = j;
                 j += 1;
             }
+            // 删除旧的 codexl provider 表块，准备写入新的。
             lines.splice(i, j - i);
             insertAfterIndex = i - 1;
             i = j - 1;
         }
     }
-    const blockLines = block.split("\n");
     if (insertAfterIndex >= 0) {
         lines.splice(insertAfterIndex + 1, 0, "", ...blockLines);
     }
     else {
-        if (!hasGlobalModelProvider) {
-            const firstNonEmptyIndex = lines.findIndex((line) => line.trim() !== "");
-            if (firstNonEmptyIndex >= 0) {
-                lines.splice(firstNonEmptyIndex, 0, 'model_provider = "codexl"', "");
-            }
-            else {
-                lines.push('model_provider = "codexl"', "");
-            }
-        }
         if (lines.length > 0 && lines[lines.length - 1].trim() !== "") {
             lines.push("");
         }
         lines.push(...blockLines);
     }
     const nextContent = `${lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}\n`;
-    node_fs_1.default.writeFileSync(targetFile, nextContent, "utf8");
+    writeFileAtomic(targetFile, nextContent);
     if (!options?.silent) {
         const config = (0, config_1.loadConfig)();
         console.log(`已写入: ${targetFile}`);
@@ -312,6 +357,8 @@ function deactivateManagedCodexConfig() {
  */
 async function main() {
     const program = new commander_1.Command();
+    // 禁用内置 help 子命令，仅保留 --help / -h 形式。
+    program.addHelpCommand(false);
     (0, config_1.getCodexSwHome)();
     (0, config_1.loadConfig)();
     program
@@ -339,8 +386,9 @@ async function main() {
     program
         .command("status")
         .description("刷新并查看所有已录入账号或工作空间的最新额度")
-        .action(async () => {
-        await handleStatus();
+        .option("--no-interactive", "仅输出状态表，不进入交互式切换")
+        .action(async (options) => {
+        await handleStatus(options);
     });
     program
         .command("start")

package/dist/server.js

@@ -49,7 +49,7 @@ function resolveBlockWindow(picked, errorText) {
         picked.status.isFiveHourLimited) {
         return {
             until: picked.status.fiveHourResetsAt ?? Math.floor(Date.now() / 1000) + 5 * 60,
-            reason: "five_hour_limited"
+            reason: "5h_limited"
         };
     }
     return {
@@ -57,6 +57,18 @@ function resolveBlockWindow(picked, errorText) {
         reason: "temporary_5m_limit"
     };
 }
+/**
+ * 为当前请求失败的账号设置临时熔断状态，避免短时间内被重复选中。
+ *
+ * @param accountId 账号标识。
+ * @param reason 本地状态中记录的失败原因。
+ * @param blockSeconds 熔断持续秒数。
+ * @returns 无返回值。
+ */
+function markAccountFailure(accountId, reason, blockSeconds) {
+    // 请求链路中的短期失败通常是瞬时异常，记录一个较短的本地熔断窗口即可。
+    (0, state_1.setAccountBlock)(accountId, Math.floor(Date.now() / 1000) + blockSeconds, reason);
+}
 /**
  * 启动一个极轻量本地服务，供后续接入代理或脚本化查询使用。
  *
@@ -115,16 +127,12 @@ async function startServer(port) {
         };
         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) {
+                // 当前账号认证信息不完整时，先做短时熔断，再切到下一个账号。
+                markAccountFailure(picked.account.id, "invalid_account_auth", 10 * 60);
                 lastErrorPayload = {
                     error: {
                         message: `账号 ${picked.account.id} 缺少 access_token`,
@@ -145,12 +153,41 @@ async function startServer(port) {
                 },
                 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;
+            let upstream;
+            try {
                 upstream = await sendUpstream();
             }
+            catch (error) {
+                // 上游连接异常通常是账号或链路瞬时问题，短时标记后继续尝试下一个账号。
+                markAccountFailure(picked.account.id, "request_failed", 60);
+                lastStatusCode = 503;
+                lastErrorPayload = {
+                    error: {
+                        message: `账号 ${picked.account.id} 请求上游失败: ${error instanceof Error ? error.message : String(error)}`,
+                        type: "account_request_failed"
+                    }
+                };
+                continue;
+            }
+            if (upstream.statusCode === 401) {
+                try {
+                    const refreshed = await (0, usage_sync_1.refreshAccountTokens)(picked.account.id);
+                    accessToken = refreshed.tokens?.access_token ?? accessToken;
+                    upstream = await sendUpstream();
+                }
+                catch (error) {
+                    // token 刷新失败说明该账号短期内不可用，先熔断再切换。
+                    markAccountFailure(picked.account.id, "token_refresh_failed", 10 * 60);
+                    lastStatusCode = 503;
+                    lastErrorPayload = {
+                        error: {
+                            message: `账号 ${picked.account.id} 刷新 token 失败: ${error instanceof Error ? error.message : String(error)}`,
+                            type: "account_token_refresh_failed"
+                        }
+                    };
+                    continue;
+                }
+            }
             if (upstream.statusCode === 429 || upstream.statusCode === 403) {
                 const errorText = await upstream.body.text();
                 const block = resolveBlockWindow(picked, errorText);
@@ -179,6 +216,18 @@ async function startServer(port) {
                     };
                     continue;
                 }
+                if (upstream.statusCode >= 500) {
+                    // 上游 5xx 先视为当前账号链路失败，短时熔断并切到下一个账号。
+                    markAccountFailure(picked.account.id, "upstream_5xx", 60);
+                    lastStatusCode = upstream.statusCode;
+                    lastErrorPayload = {
+                        error: {
+                            message: `账号 ${picked.account.id} 上游异常: ${errorText}`,
+                            type: "account_upstream_failed"
+                        }
+                    };
+                    continue;
+                }
                 reply.raw.writeHead(upstream.statusCode, {
                     "content-type": "application/json"
                 });

package/dist/status.js

@@ -31,6 +31,62 @@ function formatReset(unixSeconds) {
         hour12: false
     });
 }
+function formatLimitStatus(label, resetAt) {
+    const remaining = formatRemainingDuration(resetAt);
+    if (!remaining) {
+        return label;
+    }
+    return `${label}(${remaining})`;
+}
+function normalizeBlockReason(reason) {
+    if (!reason) {
+        return "blocked";
+    }
+    if (reason === "five_hour_limited") {
+        return "5h_limited";
+    }
+    return reason;
+}
+/**
+ * 将剩余秒数格式化为紧凑的人类可读文本，便于在状态列中展示熔断剩余时间。
+ *
+ * @param unixSeconds 熔断截止时间，Unix 秒时间戳。
+ * @returns 格式化后的剩余时长；当时间为空或已过期时返回 `null`。
+ */
+function formatRemainingDuration(unixSeconds) {
+    if (!unixSeconds) {
+        return null;
+    }
+    const diffSeconds = unixSeconds - Math.floor(Date.now() / 1000);
+    if (diffSeconds <= 0) {
+        return null;
+    }
+    const hours = Math.floor(diffSeconds / 3600);
+    const minutes = Math.floor((diffSeconds % 3600) / 60);
+    const seconds = diffSeconds % 60;
+    if (hours > 0) {
+        return `${hours}h${minutes}m`;
+    }
+    if (minutes > 0) {
+        return `${minutes}m${seconds}s`;
+    }
+    return `${seconds}s`;
+}
+/**
+ * 将本地熔断原因与剩余时间格式化为更直观的状态文本。
+ *
+ * @param reason 熔断原因。
+ * @param until 熔断截止时间，Unix 秒时间戳。
+ * @returns 适合在终端表格中展示的状态文本。
+ */
+function formatBlockedStatus(reason, until) {
+    const label = normalizeBlockReason(reason);
+    const remaining = formatRemainingDuration(until ?? null);
+    if (!remaining) {
+        return label;
+    }
+    return `${label}(${remaining})`;
+}
 /**
  * 汇总所有受管账号的运行状态，供状态展示与调度复用。
  *
@@ -94,13 +150,13 @@ function renderStatusTable(statuses) {
                 status = "disabled";
             }
             else if (item.localBlockUntil && item.localBlockUntil * 1000 > Date.now()) {
-                status = item.localBlockReason ?? "blocked";
+                status = formatBlockedStatus(item.localBlockReason, item.localBlockUntil);
             }
             else if (item.isWeeklyLimited) {
-                status = "weekly_limited";
+                status = formatLimitStatus("weekly_limited", item.weeklyResetsAt);
             }
             else if (item.isFiveHourLimited) {
-                status = "5h_limited";
+                status = formatLimitStatus("5h_limited", item.fiveHourResetsAt);
             }
             else if (item.isAvailable) {
                 status = "available";

package/dist/usage-sync.js

@@ -2,11 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.refreshAccountTokens = refreshAccountTokens;
 exports.refreshAccountUsage = refreshAccountUsage;
+exports.isUsageCacheStale = isUsageCacheStale;
+exports.refreshAccountUsageInBackgroundIfNeeded = refreshAccountUsageInBackgroundIfNeeded;
 exports.refreshAllAccountUsage = refreshAllAccountUsage;
 const undici_1 = require("undici");
 const account_store_1 = require("./account-store");
 const config_1 = require("./config");
 const state_1 = require("./state");
+const USAGE_CACHE_TTL_MS = 60 * 1000;
+const inflightUsageRefreshes = new Map();
 function normalizeResetAt(value, resetAfterSeconds) {
     if (typeof value === "number" && Number.isFinite(value)) {
         return value;
@@ -113,11 +117,53 @@ async function refreshAccountUsage(accountId) {
         fiveHourUsedPercent: payload.rate_limit?.primary_window?.used_percent ?? null,
         fiveHourResetAt: normalizeResetAt(payload.rate_limit?.primary_window?.reset_at, payload.rate_limit?.primary_window?.reset_after_seconds),
         weeklyUsedPercent: payload.rate_limit?.secondary_window?.used_percent ?? null,
-        weeklyResetAt: normalizeResetAt(payload.rate_limit?.secondary_window?.reset_at, payload.rate_limit?.secondary_window?.reset_after_seconds)
+        weeklyResetAt: normalizeResetAt(payload.rate_limit?.secondary_window?.reset_at, payload.rate_limit?.secondary_window?.reset_after_seconds),
+        refreshedAt: new Date().toISOString()
     };
     (0, state_1.setUsageCache)(result);
     return result;
 }
+/**
+ * 判断指定账号的额度缓存是否已经过期。
+ *
+ * @param accountId 账号标识。
+ * @returns `true` 表示不存在缓存或缓存已超过 TTL，需要重新刷新；`false` 表示缓存仍可直接复用。
+ */
+function isUsageCacheStale(accountId) {
+    const usageCache = (0, state_1.getUsageCache)(accountId);
+    if (!usageCache?.refreshedAt) {
+        return true;
+    }
+    const refreshedAt = Date.parse(usageCache.refreshedAt);
+    if (Number.isNaN(refreshedAt)) {
+        return true;
+    }
+    return Date.now() - refreshedAt > USAGE_CACHE_TTL_MS;
+}
+/**
+ * 在不阻塞主请求链路的前提下，按需异步刷新指定账号的额度缓存。
+ *
+ * @param accountId 账号标识。
+ * @returns 无返回值；若缓存仍在 TTL 内或已有刷新任务进行中则直接跳过。
+ */
+function refreshAccountUsageInBackgroundIfNeeded(accountId) {
+    if (!isUsageCacheStale(accountId) || inflightUsageRefreshes.has(accountId)) {
+        return;
+    }
+    // 同一账号同一时刻只保留一个后台刷新任务，避免高并发下重复打远端 usage 接口。
+    const refreshTask = (async () => {
+        try {
+            await refreshAccountUsage(accountId);
+        }
+        catch {
+            // 后台刷新失败时保留旧缓存，由正式转发请求中的错误处理继续兜底。
+        }
+        finally {
+            inflightUsageRefreshes.delete(accountId);
+        }
+    })();
+    inflightUsageRefreshes.set(accountId, refreshTask);
+}
 /**
  * 批量刷新所有受管账号的额度信息。
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openxiaobu/codexl",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "本地 Codex 多账号切换与状态管理工具",
   "type": "commonjs",
   "main": "dist/cli.js",