codex-slot 0.1.19 → 0.1.20

package/dist/state-repository.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSchedulerStatsSnapshot = loadSchedulerStatsSnapshot;
+exports.recordAccountScheduleSuccess = recordAccountScheduleSuccess;
+const state_1 = require("./state");
+/**
+ * 读取全部账号的调度统计快照。
+ *
+ * 业务含义：
+ * 1. 调度器一次调度只读取一次统计，避免评分过程中反复触碰 state 文件。
+ * 2. 返回值是普通对象快照，调用方不得把它当作可自动持久化的引用。
+ *
+ * @returns 账号调度统计表；key 为账号 id。
+ * @throws 当 state 文件读取或 JSON 解析失败时透传底层异常。
+ */
+function loadSchedulerStatsSnapshot() {
+    return (0, state_1.loadState)().scheduler_stats;
+}
+/**
+ * 记录指定账号完成一次成功代理请求。
+ *
+ * 业务含义：
+ * 1. 该统计只服务于调度均匀分摊，不参与额度判断。
+ * 2. 每次成功上游响应后递增成功次数并刷新最近成功时间。
+ *
+ * @param accountId 账号标识；必须是当前配置中的受管账号 id。
+ * @returns 无返回值。
+ * @throws 当 state 文件写入失败时透传底层异常。
+ */
+function recordAccountScheduleSuccess(accountId) {
+    (0, state_1.updateState)((state) => {
+        const current = state.scheduler_stats[accountId] ?? {
+            success_count: 0,
+            last_success_at: null
+        };
+        state.scheduler_stats[accountId] = {
+            success_count: current.success_count + 1,
+            last_success_at: new Date().toISOString()
+        };
+    });
+}

package/dist/state.js

@@ -5,7 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadState = loadState;
 exports.saveState = saveState;
+exports.updateState = updateState;
 exports.setAccountBlock = setAccountBlock;
+exports.clearAccountBlock = clearAccountBlock;
 exports.pruneExpiredBlocks = pruneExpiredBlocks;
 exports.getAccountBlock = getAccountBlock;
 exports.setUsageCache = setUsageCache;
@@ -13,8 +15,6 @@ exports.getUsageCache = getUsageCache;
 exports.setUsageRefreshError = setUsageRefreshError;
 exports.clearUsageRefreshError = clearUsageRefreshError;
 exports.getUsageRefreshError = getUsageRefreshError;
-exports.getSchedulerStats = getSchedulerStats;
-exports.recordAccountScheduleSuccess = recordAccountScheduleSuccess;
 exports.getManagedCodexConfigState = getManagedCodexConfigState;
 exports.getManagedCodexAuthState = getManagedCodexAuthState;
 exports.setManagedCodexConfigState = setManagedCodexConfigState;
@@ -24,9 +24,50 @@ exports.clearManagedCodexAuthState = clearManagedCodexAuthState;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const config_1 = require("./config");
+const STATE_SCHEMA_VERSION = 1;
 function getStatePath() {
     return node_path_1.default.join((0, config_1.getCslotHome)(), "state.json");
 }
+/**
+ * 构造当前版本的默认本地状态对象。
+ *
+ * 业务含义：
+ * 1. 所有缺失或空 state 文件统一走这里补齐字段。
+ * 2. 新增状态字段时只需要在默认状态与归一化逻辑中集中维护。
+ *
+ * @returns 当前 schema 版本的默认状态。
+ * @throws 无显式抛出。
+ */
+function createDefaultState() {
+    return {
+        state_version: STATE_SCHEMA_VERSION,
+        account_blocks: {},
+        usage_cache: {},
+        usage_refresh_errors: {},
+        scheduler_stats: {},
+        managed_codex_auth: null,
+        managed_codex_config: null
+    };
+}
+/**
+ * 将历史版本或字段缺失的 state 归一化为当前 schema。
+ *
+ * @param parsed 从 state 文件解析出的原始对象。
+ * @returns 补齐默认字段后的当前版本状态。
+ * @throws 无显式抛出。
+ */
+function normalizeState(parsed) {
+    const defaults = createDefaultState();
+    return {
+        state_version: STATE_SCHEMA_VERSION,
+        account_blocks: parsed?.account_blocks ?? defaults.account_blocks,
+        usage_cache: parsed?.usage_cache ?? defaults.usage_cache,
+        usage_refresh_errors: parsed?.usage_refresh_errors ?? defaults.usage_refresh_errors,
+        scheduler_stats: parsed?.scheduler_stats ?? defaults.scheduler_stats,
+        managed_codex_auth: parsed?.managed_codex_auth ?? defaults.managed_codex_auth,
+        managed_codex_config: parsed?.managed_codex_config ?? defaults.managed_codex_config
+    };
+}
 /**
  * 读取 cslot 的本地运行状态；文件不存在时返回默认空状态。
  *
@@ -35,34 +76,10 @@ function getStatePath() {
 function loadState() {
     const statePath = getStatePath();
     if (!node_fs_1.default.existsSync(statePath)) {
-        return {
-            account_blocks: {},
-            usage_cache: {},
-            usage_refresh_errors: {},
-            scheduler_stats: {},
-            managed_codex_auth: null,
-            managed_codex_config: null
-        };
+        return createDefaultState();
     }
     const raw = node_fs_1.default.readFileSync(statePath, "utf8");
-    const parsed = raw.trim()
-        ? JSON.parse(raw)
-        : {
-            account_blocks: {},
-            usage_cache: {},
-            usage_refresh_errors: {},
-            scheduler_stats: {},
-            managed_codex_auth: null,
-            managed_codex_config: null
-        };
-    return {
-        account_blocks: parsed.account_blocks ?? {},
-        usage_cache: parsed.usage_cache ?? {},
-        usage_refresh_errors: parsed.usage_refresh_errors ?? {},
-        scheduler_stats: parsed.scheduler_stats ?? {},
-        managed_codex_auth: parsed.managed_codex_auth ?? null,
-        managed_codex_config: parsed.managed_codex_config ?? null
-    };
+    return normalizeState(raw.trim() ? JSON.parse(raw) : null);
 }
 /**
  * 持久化 cslot 的本地运行状态。
@@ -72,7 +89,27 @@ function loadState() {
  */
 function saveState(state) {
     const statePath = getStatePath();
-    node_fs_1.default.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    const normalizedState = normalizeState(state);
+    const tempPath = `${statePath}.${process.pid}.${Date.now()}.tmp`;
+    node_fs_1.default.writeFileSync(tempPath, `${JSON.stringify(normalizedState, null, 2)}\n`, "utf8");
+    node_fs_1.default.renameSync(tempPath, statePath);
+}
+/**
+ * 在单一边界内读取、修改并保存本地状态。
+ *
+ * 业务含义：
+ * 1. 所有状态写入都统一经过当前函数，避免各模块散落 load/mutate/save 流程。
+ * 2. 保存阶段复用原子替换写入，降低半写入状态文件风险。
+ *
+ * @param mutator 状态修改函数；接收当前状态对象并可原地修改。
+ * @returns 修改后已保存的状态对象。
+ * @throws 当读取、修改或写入失败时透传底层异常。
+ */
+function updateState(mutator) {
+    const state = loadState();
+    mutator(state);
+    saveState(state);
+    return state;
 }
 /**
  * 为指定账号设置本地禁用窗口，用于临时熔断或周限制冷却。
@@ -83,13 +120,24 @@ function saveState(state) {
  * @returns 无返回值。
  */
 function setAccountBlock(accountId, until, reason) {
-    const state = loadState();
-    state.account_blocks[accountId] = {
-        until,
-        reason,
-        updated_at: new Date().toISOString()
-    };
-    saveState(state);
+    updateState((state) => {
+        state.account_blocks[accountId] = {
+            until,
+            reason,
+            updated_at: new Date().toISOString()
+        };
+    });
+}
+/**
+ * 清理指定账号当前记录的本地禁用状态。
+ *
+ * @param accountId 账号标识。
+ * @returns 无返回值。
+ */
+function clearAccountBlock(accountId) {
+    updateState((state) => {
+        delete state.account_blocks[accountId];
+    });
 }
 /**
  * 清理已过期的账号禁用记录，并返回最新状态。
@@ -107,7 +155,16 @@ function pruneExpiredBlocks() {
         }
     }
     if (changed) {
-        saveState(state);
+        updateState((latest) => {
+            for (const accountId of Object.keys(state.account_blocks)) {
+                latest.account_blocks[accountId] = state.account_blocks[accountId];
+            }
+            for (const accountId of Object.keys(latest.account_blocks)) {
+                if (!(accountId in state.account_blocks)) {
+                    delete latest.account_blocks[accountId];
+                }
+            }
+        });
     }
     return state;
 }
@@ -128,9 +185,9 @@ function getAccountBlock(accountId) {
  * @returns 无返回值。
  */
 function setUsageCache(usage) {
-    const state = loadState();
-    state.usage_cache[usage.accountId] = usage;
-    saveState(state);
+    updateState((state) => {
+        state.usage_cache[usage.accountId] = usage;
+    });
 }
 /**
  * 读取指定账号最近一次成功刷新的额度缓存。
@@ -149,9 +206,9 @@ function getUsageCache(accountId) {
  * @returns 无返回值。
  */
 function setUsageRefreshError(usageError) {
-    const state = loadState();
-    state.usage_refresh_errors[usageError.accountId] = usageError;
-    saveState(state);
+    updateState((state) => {
+        state.usage_refresh_errors[usageError.accountId] = usageError;
+    });
 }
 /**
  * 清理指定账号最近一次记录的额度刷新失败状态，避免后续成功刷新后继续展示旧错误。
@@ -160,12 +217,9 @@ function setUsageRefreshError(usageError) {
  * @returns 无返回值。
  */
 function clearUsageRefreshError(accountId) {
-    const state = loadState();
-    if (!(accountId in state.usage_refresh_errors)) {
-        return;
-    }
-    delete state.usage_refresh_errors[accountId];
-    saveState(state);
+    updateState((state) => {
+        delete state.usage_refresh_errors[accountId];
+    });
 }
 /**
  * 读取指定账号最近一次记录的额度刷新失败状态。
@@ -177,37 +231,6 @@ function getUsageRefreshError(accountId) {
     const state = loadState();
     return state.usage_refresh_errors[accountId] ?? null;
 }
-/**
- * 读取指定账号的调度使用统计，用于在多账号可用时做均匀分摊。
- *
- * @param accountId 账号标识。
- * @returns 调度统计；不存在时返回默认零值。
- */
-function getSchedulerStats(accountId) {
-    const state = loadState();
-    return state.scheduler_stats[accountId] ?? {
-        success_count: 0,
-        last_success_at: null
-    };
-}
-/**
- * 记录指定账号完成一次成功代理请求，供后续调度降低连续命中同一账号的概率。
- *
- * @param accountId 账号标识。
- * @returns 无返回值。
- */
-function recordAccountScheduleSuccess(accountId) {
-    const state = loadState();
-    const current = state.scheduler_stats[accountId] ?? {
-        success_count: 0,
-        last_success_at: null
-    };
-    state.scheduler_stats[accountId] = {
-        success_count: current.success_count + 1,
-        last_success_at: new Date().toISOString()
-    };
-    saveState(state);
-}
 /**
  * 读取当前记录的 Codex `config.toml` 接管快照。
  *
@@ -233,9 +256,9 @@ function getManagedCodexAuthState() {
  * @returns 无返回值。
  */
 function setManagedCodexConfigState(managedState) {
-    const state = loadState();
-    state.managed_codex_config = managedState;
-    saveState(state);
+    updateState((state) => {
+        state.managed_codex_config = managedState;
+    });
 }
 /**
  * 保存 Codex 主 HOME 登录态接管快照，用于 stop 时恢复原始登录态文件。
@@ -244,9 +267,9 @@ function setManagedCodexConfigState(managedState) {
  * @returns 无返回值。
  */
 function setManagedCodexAuthState(managedState) {
-    const state = loadState();
-    state.managed_codex_auth = managedState;
-    saveState(state);
+    updateState((state) => {
+        state.managed_codex_auth = managedState;
+    });
 }
 /**
  * 清理 Codex `config.toml` 接管快照。
@@ -254,9 +277,9 @@ function setManagedCodexAuthState(managedState) {
  * @returns 无返回值。
  */
 function clearManagedCodexConfigState() {
-    const state = loadState();
-    state.managed_codex_config = null;
-    saveState(state);
+    updateState((state) => {
+        state.managed_codex_config = null;
+    });
 }
 /**
  * 清理 Codex 主 HOME 登录态接管快照。
@@ -264,7 +287,7 @@ function clearManagedCodexConfigState() {
  * @returns 无返回值。
  */
 function clearManagedCodexAuthState() {
-    const state = loadState();
-    state.managed_codex_auth = null;
-    saveState(state);
+    updateState((state) => {
+        state.managed_codex_auth = null;
+    });
 }

package/dist/upstream-client.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUpstreamHeaders = buildUpstreamHeaders;
+exports.sendCodexResponsesRequest = sendCodexResponsesRequest;
+const undici_1 = require("undici");
+/**
+ * 构造发往上游的请求头，并移除仅属于本地代理链路的头信息。
+ *
+ * 业务含义：
+ * 1. 本地服务使用独立 api_key 鉴权，转发时必须替换为真实上游 access token。
+ * 2. body 会在本地先读取成 Buffer 以支持失败后切换账号重试，因此这里重算 content-length。
+ *
+ * @param requestHeaders 客户端发到本地服务的原始请求头。
+ * @param accessToken 当前候选账号可用的上游访问令牌。
+ * @param bodyLength 请求体字节长度。
+ * @param accountIdHeader 可选的 ChatGPT 账号标识头。
+ * @returns 可直接传给上游请求的请求头对象。
+ * @throws 无显式抛出。
+ */
+function buildUpstreamHeaders(requestHeaders, accessToken, bodyLength, accountIdHeader) {
+    const headers = {};
+    for (const [headerName, headerValue] of Object.entries(requestHeaders)) {
+        const normalizedName = headerName.toLowerCase();
+        if (headerValue == null ||
+            normalizedName === "authorization" ||
+            normalizedName === "host" ||
+            normalizedName === "connection" ||
+            normalizedName === "content-length") {
+            continue;
+        }
+        headers[normalizedName] = Array.isArray(headerValue)
+            ? headerValue.join(", ")
+            : headerValue;
+    }
+    headers.authorization = `Bearer ${accessToken}`;
+    if (!headers.accept) {
+        headers.accept = "text/event-stream, application/json";
+    }
+    headers["content-length"] = String(bodyLength);
+    headers["user-agent"] = "codex-slot/0.1.1";
+    if (accountIdHeader) {
+        headers["chatgpt-account-id"] = accountIdHeader;
+    }
+    return headers;
+}
+/**
+ * 向 Codex responses 上游发送一次请求。
+ *
+ * 业务含义：
+ * 1. 该 Adapter 隔离 undici 与上游 URL 细节，代理重试服务不直接依赖 HTTP 客户端实现。
+ * 2. 调用方负责决定 access token、账号切换与失败策略。
+ *
+ * @param options 上游请求参数。
+ * @returns undici 上游响应对象。
+ * @throws 当网络层或 undici 请求失败时透传底层异常。
+ */
+async function sendCodexResponsesRequest(options) {
+    return await (0, undici_1.request)(`${options.codexBaseUrl}/responses`, {
+        method: "POST",
+        headers: buildUpstreamHeaders(options.requestHeaders, options.accessToken, options.body.length, options.accountIdHeader),
+        body: options.body
+    });
+}

package/dist/upstream-error-policy.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBlockWindow = resolveBlockWindow;
+exports.extractErrorCode = extractErrorCode;
+exports.isNetworkUnavailableError = isNetworkUnavailableError;
+exports.buildNetworkUnavailablePayload = buildNetworkUnavailablePayload;
+exports.isUsageLimitErrorText = isUsageLimitErrorText;
+const text_1 = require("./text");
+/**
+ * 根据错误文本与当前账号状态，决定本地禁用时长。
+ *
+ * 业务规则：
+ * 1. 周限制优先，直到周窗口重置时间。
+ * 2. 5 小时额度限制次之，直到 5 小时窗口重置时间。
+ * 3. 未能明确识别时，按 5 分钟临时熔断处理。
+ *
+ * @param picked 当前被选中的账号及状态。
+ * @param errorText 上游返回的错误文本。
+ * @returns 本地禁用窗口与原因。
+ * @throws 无显式抛出。
+ */
+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: "5h_limited"
+        };
+    }
+    return {
+        until: Math.floor(Date.now() / 1000) + 5 * 60,
+        reason: "temporary_5m_limit"
+    };
+}
+/**
+ * 提取错误对象中最接近底层网络层的错误码。
+ *
+ * @param error 捕获到的异常对象。
+ * @returns 错误码；若无法识别则返回 `null`。
+ * @throws 无显式抛出。
+ */
+function extractErrorCode(error) {
+    if (!error || typeof error !== "object") {
+        return null;
+    }
+    const errnoError = error;
+    if (typeof errnoError.code === "string" && errnoError.code.length > 0) {
+        return errnoError.code;
+    }
+    return extractErrorCode(errnoError.cause);
+}
+/**
+ * 判断一次请求失败是否属于本机到上游之间的网络不可达场景。
+ *
+ * @param error 捕获到的异常对象。
+ * @returns `true` 表示网络层异常，不应写入账号熔断；否则返回 `false`。
+ * @throws 无显式抛出。
+ */
+function isNetworkUnavailableError(error) {
+    const errorCode = extractErrorCode(error);
+    return [
+        "ECONNREFUSED",
+        "ECONNRESET",
+        "EHOSTUNREACH",
+        "ENETDOWN",
+        "ENETUNREACH",
+        "ENOTFOUND",
+        "EAI_AGAIN",
+        "ETIMEDOUT",
+        "UND_ERR_CONNECT_TIMEOUT",
+        "UND_ERR_SOCKET"
+    ].includes(errorCode ?? "");
+}
+/**
+ * 将网络层异常转换为统一的响应体，避免误导成“当前没有可用账号”。
+ *
+ * @param accountId 当前尝试的账号标识。
+ * @param error 捕获到的异常对象。
+ * @returns 统一的网络异常响应体。
+ * @throws 无显式抛出。
+ */
+function buildNetworkUnavailablePayload(accountId, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        error: {
+            message: (0, text_1.bi)(`网络不可用，账号 ${accountId} 无法连接上游: ${message}`, `Network unavailable. Account ${accountId} cannot reach upstream: ${message}`),
+            type: "network_unavailable"
+        }
+    };
+}
+/**
+ * 判断错误响应文本是否表示上游额度限制。
+ *
+ * @param errorText 上游返回的错误文本。
+ * @returns `true` 表示可按额度限制处理并切换账号。
+ * @throws 无显式抛出。
+ */
+function isUsageLimitErrorText(errorText) {
+    const lowerText = errorText.toLowerCase();
+    return lowerText.includes("usage limit") || lowerText.includes("try again later");
+}

package/dist/usage-sync.js

@@ -12,6 +12,12 @@ const state_1 = require("./state");
 const text_1 = require("./text");
 const USAGE_CACHE_TTL_MS = 60 * 1000;
 const inflightUsageRefreshes = new Map();
+const SHORT_LIVED_ACCOUNT_BLOCK_REASONS = new Set([
+    "request_failed",
+    "upstream_5xx",
+    "temporary_5m_limit",
+    "token_refresh_failed"
+]);
 function normalizeResetAt(value, resetAfterSeconds) {
     if (typeof value === "number" && Number.isFinite(value)) {
         return value;
@@ -21,6 +27,21 @@ function normalizeResetAt(value, resetAfterSeconds) {
     }
     return null;
 }
+/**
+ * 当账号已经成功完成鉴权或额度刷新时，清理与瞬时异常相关的本地熔断。
+ *
+ * 只会移除短期失败类熔断，不会误清理 5 小时或周额度限制。
+ *
+ * @param accountId 账号标识。
+ * @returns 无返回值。
+ */
+function clearShortLivedAccountBlock(accountId) {
+    const block = (0, state_1.getAccountBlock)(accountId);
+    if (!block || !SHORT_LIVED_ACCOUNT_BLOCK_REASONS.has(block.reason)) {
+        return;
+    }
+    (0, state_1.clearAccountBlock)(accountId);
+}
 /**
  * 将额度刷新异常归类为可直接展示在 `status` 表格中的状态码。
  *
@@ -96,6 +117,7 @@ async function refreshAccountTokens(accountId) {
         last_refresh: new Date().toISOString()
     };
     (0, account_store_1.writeAuthFile)(account.codex_home, nextAuth);
+    clearShortLivedAccountBlock(accountId);
     return nextAuth;
 }
 /**
@@ -149,6 +171,7 @@ async function refreshAccountUsage(accountId) {
     };
     (0, state_1.setUsageCache)(result);
     (0, state_1.clearUsageRefreshError)(accountId);
+    clearShortLivedAccountBlock(accountId);
     return result;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-slot",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "本地 Codex 多账号切换与状态管理工具",
   "type": "commonjs",
   "main": "dist/cli.js",
@@ -12,8 +12,8 @@
     "dist"
   ],
   "scripts": {
-    "clean": "rm -rf dist",
-    "build": "npm run clean && tsc -p tsconfig.json && chmod +x dist/cli.js dist/serve.js",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.json && node -e \"const fs=require('node:fs'); for (const file of ['dist/cli.js','dist/serve.js']) { try { fs.chmodSync(file, 0o755); } catch {} }\"",
     "prepublishOnly": "npm run build",
     "dev": "tsx src/cli.ts",
     "check": "tsc --noEmit -p tsconfig.json",