codex-slot 0.1.26 → 0.1.28

package/dist/cli.js

@@ -81,6 +81,7 @@ function registerAccountCommands(program) {
 function registerRuntimeCommands(program) {
     program
         .command("status")
+        .alias("usage")
         .description((0, text_1.bi)("刷新并查看所有已录入账号或工作空间的最新额度", "Refresh usage for all managed slots"))
         .option("--no-interactive", (0, text_1.bi)("仅输出状态表，不进入交互式切换", "Print only"))
         .action(async (options) => {

package/dist/codex-config.js

@@ -325,53 +325,6 @@ function findTableHeaderOffset(content, header) {
     }
     return null;
 }
-/**
- * 查找指定偏移之前最近的表头，供恢复原有表块位置时作为后备锚点。
- *
- * @param content 当前 `config.toml` 内容。
- * @param offset 截止偏移。
- * @returns 最近的表头文本；未命中返回 `null`。
- */
-function findPreviousTableHeaderBeforeOffset(content, offset) {
-    const lines = content.split(/\r?\n/);
-    let currentOffset = 0;
-    let previousHeader = null;
-    for (const line of lines) {
-        const lineEnd = currentOffset + line.length;
-        const trimmed = line.trim();
-        if (currentOffset >= offset) {
-            break;
-        }
-        if (trimmed.startsWith("[") && !trimmed.startsWith("[[") && !trimmed.startsWith("#")) {
-            previousHeader = trimmed;
-        }
-        currentOffset = lineEnd + (content.slice(lineEnd, lineEnd + 2) === "\r\n" ? 2 : 1);
-    }
-    return previousHeader;
-}
-/**
- * 查找指定偏移之后的首个表头，供恢复原有表块位置时作为优先锚点。
- *
- * @param content 当前 `config.toml` 内容。
- * @param offset 起始偏移。
- * @returns 首个后续表头文本；未命中返回 `null`。
- */
-function findNextTableHeaderAfterOffset(content, offset) {
-    const lines = content.split(/\r?\n/);
-    let currentOffset = 0;
-    for (const line of lines) {
-        const lineEnd = currentOffset + line.length;
-        const trimmed = line.trim();
-        if (currentOffset >= offset &&
-            trimmed.startsWith("[") &&
-            !trimmed.startsWith("[[") &&
-            !trimmed.startsWith("#")) {
-            return trimmed;
-        }
-        currentOffset = lineEnd + (content.slice(lineEnd, lineEnd + 2) === "\r\n" ? 2 : 1);
-    }
-    return null;
-}
 /**
  * 清理文本中的所有 `model_provider` 配置块，确保每次接管都以单一稳定块重新写入。
  *
@@ -414,6 +367,35 @@ function stripAllManagedBlocks(content) {
     const withoutProviderBlock = stripMarkedBlocks(content, PROVIDER_BLOCK_START_MARKER, PROVIDER_BLOCK_END_MARKER);
     return stripMarkedBlocks(withoutProviderBlock, MODEL_PROVIDER_START_MARKER, MODEL_PROVIDER_END_MARKER);
 }
+/**
+ * 清理文本中的所有 `model_provider = "cslot"` 根级配置，避免 stop 后残留 cslot 入口。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @returns 移除后的文本内容。
+ */
+function removeAllCslotModelProviderLines(content) {
+    let nextContent = content;
+    while (true) {
+        const range = findModelProviderLine(nextContent);
+        if (!range) {
+            return nextContent;
+        }
+        if (range.value.includes('model_provider = "cslot"')) {
+            nextContent = nextContent.slice(0, range.start) + nextContent.slice(range.end);
+            continue;
+        }
+        return nextContent;
+    }
+}
+/**
+ * 在 stop 阶段只做去 cslot 化，移除所有受管块与残留的 cslot provider 配置。
+ *
+ * @param content 当前 `config.toml` 内容。
+ * @returns 已去除 cslot 接管痕迹的文本。
+ */
+function removeAllCslotManagedConfig(content) {
+    return removeAllProviderSections(removeAllCslotModelProviderLines(stripAllManagedBlocks(content)));
+}
 /**
  * 查找根级配置区的尾部插入点。
  *
@@ -487,86 +469,6 @@ function appendBlockToEnd(content, block, eol) {
     }
     return `${trimmed}${eol}${eol}${block}${eol}`;
 }
-/**
- * 将表块尽量插回原有相邻表头附近；若锚点已不存在，则退回文件尾部追加。
- *
- * @param content 当前 `config.toml` 内容。
- * @param block 待插入的表块。
- * @param eol 目标换行符。
- * @param preferredNextTableHeader 原始后续表头锚点，命中时优先插到该表之前。
- * @param preferredPreviousTableHeader 原始前驱表头锚点，当前者失效时插到该表之后。
- * @returns 插入后的完整文本。
- */
-function insertTableBlock(content, block, eol, preferredNextTableHeader, preferredPreviousTableHeader) {
-    if (preferredNextTableHeader) {
-        const nextOffset = findTableHeaderOffset(content, preferredNextTableHeader);
-        if (nextOffset !== null) {
-            return insertBlockBetween(content.slice(0, nextOffset), block, content.slice(nextOffset), eol);
-        }
-    }
-    if (preferredPreviousTableHeader) {
-        const previousRange = findTableSectionRange(content, preferredPreviousTableHeader);
-        if (previousRange) {
-            return insertBlockBetween(content.slice(0, previousRange.end), block, content.slice(previousRange.end), eol);
-        }
-    }
-    return appendBlockToEnd(content, block, eol);
-}
-/**
- * 解析当前目标文件对应的上一轮接管快照。
- *
- * @param targetFile 当前准备接管或恢复的 `config.toml` 路径。
- * @returns 命中同一目标文件时返回上一轮快照；否则返回 `null`。
- */
-function resolveManagedStateForTarget(targetFile) {
-    const managedState = (0, state_1.getManagedCodexConfigState)();
-    if (!managedState || managedState.target_file !== targetFile) {
-        return null;
-    }
-    return managedState;
-}
-/**
- * 基于当前未受管的配置文本与上一轮快照，生成本轮接管所需的最小恢复快照。
- *
- * 业务规则：
- * 1. 优先记录当前文件里实际存在的原始 `model_provider` 与 `[model_providers.cslot]`。
- * 2. 若当前文件只剩残留受管块，允许继承上一轮快照中的原始片段。
- * 3. 仅保存 cslot 自己声明所有权的两块配置及其锚点，不保存整文件内容。
- *
- * @param targetFile 当前准备接管的 `config.toml` 路径。
- * @param strippedCurrent 已移除受管标记块后的配置文本。
- * @param previousManagedState 同一目标文件的上一轮快照；不存在时传 `null`。
- * @returns 本轮接管后用于 stop 恢复的快照。
- */
-function buildManagedSnapshot(targetFile, strippedCurrent, previousManagedState) {
-    const originalModelProviderLine = findModelProviderLine(strippedCurrent);
-    const originalProviderSection = findProviderSectionRange(strippedCurrent);
-    return {
-        target_file: targetFile,
-        original_model_provider_block: originalModelProviderLine?.value ??
-            previousManagedState?.original_model_provider_block ??
-            null,
-        original_model_provider_next_table_header: (originalModelProviderLine
-            ? findNextTableHeaderAfterOffset(strippedCurrent, originalModelProviderLine.end)
-            : null) ??
-            previousManagedState?.original_model_provider_next_table_header ??
-            null,
-        original_cslot_provider_block: (originalProviderSection ? sanitizeLegacyCslotProviderBlock(originalProviderSection.value) : null) ??
-            (previousManagedState?.original_cslot_provider_block
-                ? sanitizeLegacyCslotProviderBlock(previousManagedState.original_cslot_provider_block)
-                : null),
-        original_cslot_provider_previous_table_header: (originalProviderSection
-            ? findPreviousTableHeaderBeforeOffset(strippedCurrent, originalProviderSection.start)
-            : null) ??
-            previousManagedState?.original_cslot_provider_previous_table_header ??
-            null,
-        original_cslot_provider_next_table_header: (originalProviderSection
-            ? findNextTableHeaderAfterOffset(strippedCurrent, originalProviderSection.end)
-            : null) ??
-            previousManagedState?.original_cslot_provider_next_table_header ??
-            null
-    };
-}
 /**
  * 将 cslot 需要的 provider 配置写入指定 `config.toml`，并保存恢复快照。
  *
@@ -579,21 +481,19 @@ 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 current = node_fs_1.default.existsSync(targetFile) ? node_fs_1.default.readFileSync(targetFile, "utf8") : "";
-    const previousManagedState = resolveManagedStateForTarget(targetFile);
-    const strippedCurrent = stripAllManagedBlocks(current);
-    const eol = detectEol(strippedCurrent);
-    const snapshot = buildManagedSnapshot(targetFile, strippedCurrent, previousManagedState);
+    const cleanedCurrent = removeAllCslotManagedConfig(current);
+    const eol = detectEol(cleanedCurrent);
     const config = options?.config ?? (0, config_1.loadConfig)();
     const managedModelProviderBlock = buildManagedModelProviderBlock(eol);
     const managedProviderBlock = buildManagedProviderBlock(eol, config);
-    const cleanedBaseContent = removeAllProviderSections(removeAllModelProviderLines(strippedCurrent));
-    let nextContent = insertRootBlock(cleanedBaseContent, managedModelProviderBlock, eol, snapshot.original_model_provider_next_table_header);
+    const cleanedBaseContent = removeAllProviderSections(removeAllModelProviderLines(cleanedCurrent));
+    let nextContent = insertRootBlock(cleanedBaseContent, managedModelProviderBlock, eol);
     nextContent = appendBlockToEnd(nextContent, managedProviderBlock, eol);
     if (!nextContent.endsWith(eol)) {
         nextContent = `${nextContent}${eol}`;
     }
     writeFileAtomic(targetFile, nextContent);
-    (0, state_1.setManagedCodexConfigState)(snapshot);
+    (0, state_1.setManagedCodexConfigState)({ target_file: targetFile });
     if (!options?.silent) {
         console.log((0, text_1.bi)(`已写入: ${targetFile}`, `Written to: ${targetFile}`));
         console.log(`base_url=http://${config.server.host}:${config.server.port}/v1`);
@@ -609,25 +509,13 @@ function applyManagedCodexConfig(targetPathOrDir, options) {
  */
 function deactivateManagedCodexConfig() {
     const managedState = (0, state_1.getManagedCodexConfigState)();
-    if (!managedState) {
-        return null;
-    }
-    const targetFile = managedState.target_file;
+    const targetFile = managedState?.target_file ?? getDefaultCodexConfigPath();
     if (!node_fs_1.default.existsSync(targetFile)) {
         (0, state_1.clearManagedCodexConfigState)();
         return null;
     }
     const current = node_fs_1.default.readFileSync(targetFile, "utf8");
-    const eol = detectEol(current);
-    let restored = sanitizeExistingCslotProviderSection(stripAllManagedBlocks(current));
-    const existingModelProviderLine = findModelProviderLine(restored);
-    if (!existingModelProviderLine && managedState.original_model_provider_block) {
-        restored = insertRootBlock(restored, managedState.original_model_provider_block, eol, managedState.original_model_provider_next_table_header);
-    }
-    const existingProviderSection = findProviderSectionRange(restored);
-    if (!existingProviderSection && managedState.original_cslot_provider_block) {
-        restored = insertTableBlock(restored, managedState.original_cslot_provider_block, eol, managedState.original_cslot_provider_next_table_header, managedState.original_cslot_provider_previous_table_header);
-    }
+    const restored = removeAllCslotManagedConfig(sanitizeExistingCslotProviderSection(current));
     writeFileAtomic(targetFile, restored);
     (0, state_1.clearManagedCodexConfigState)();
     return targetFile;

package/dist/proxy-retry-service.js

@@ -1,6 +1,7 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.proxyResponsesWithRetry = void 0;
+exports.proxyResponsesWithRetry = exports.proxyCodexWithRetry = void 0;
 exports.createProxyRetryService = createProxyRetryService;
 const account_store_1 = require("./account-store");
 const config_1 = require("./config");
@@ -14,6 +15,7 @@ const usage_sync_1 = require("./usage-sync");
 /**
  * 为当前请求失败的账号设置临时熔断状态，避免短时间内被重复选中。
  *
+ * @param dependencies 代理服务依赖集合。
  * @param accountId 账号标识。
  * @param reason 本地状态中记录的失败原因。
  * @param blockSeconds 熔断持续秒数。
@@ -60,24 +62,61 @@ function buildSendResult(statusCode, payload, headers) {
     };
 }
 /**
- * 对单个候选账号发送上游请求。
+ * 解析本地 Codex-compatible 代理请求，并转换成上游 codex path。
  *
+ * 业务含义：
+ * 1. 对外暴露的 `/v1/*` 请求需要统一映射到上游 `codex_base_url` 的同名子路径，避免继续按接口逐个补洞。
+ * 2. 为兼容历史入口，也保留 `/backend-api/codex/*` 映射到同一上游 path 的能力。
+ *
+ * @param request 原始本地代理请求。
+ * @returns 可发往上游的 codex path；不属于代理范围时返回错误结果。
+ * @throws 当 URL 解析失败时返回错误结果，不向上游发请求。
+ */
+function resolveCodexPath(request) {
+    const parsedUrl = new URL(request.url, "http://127.0.0.1");
+    const openAiPrefix = "/v1";
+    const legacyBackendPrefix = "/backend-api/codex";
+    if (parsedUrl.pathname.startsWith(`${openAiPrefix}/`)) {
+        return {
+            pathWithQuery: `${parsedUrl.pathname.slice(openAiPrefix.length)}${parsedUrl.search}`
+        };
+    }
+    if (parsedUrl.pathname.startsWith(`${legacyBackendPrefix}/`)) {
+        return {
+            pathWithQuery: `${parsedUrl.pathname.slice(legacyBackendPrefix.length)}${parsedUrl.search}`
+        };
+    }
+    return {
+        error: buildSendResult(404, {
+            error: {
+                message: (0, text_1.bi)("不支持的 Codex 代理路径", "Unsupported Codex proxy path"),
+                type: "unsupported_codex_proxy_path"
+            }
+        })
+    };
+}
+/**
+ * 对单个候选账号发送通用的 codex 上游请求。
+ *
+ * @param dependencies 代理服务依赖集合。
  * @param picked 当前候选账号。
  * @param accessToken 可用 access token。
- * @param requestHeaders 原始请求头。
- * @param requestBody 原始请求体。
+ * @param pathWithQuery 已解析的 codex path 与 query。
+ * @param request 原始本地代理请求。
  * @returns 上游响应。
  * @throws 当网络层或 undici 请求失败时透传底层异常。
  */
-async function sendWithAccount(dependencies, picked, accessToken, requestHeaders, requestBody) {
+async function sendWithAccount(dependencies, picked, accessToken, pathWithQuery, request) {
     const config = dependencies.loadConfig();
     const auth = dependencies.readAuthFile(picked.account.codex_home);
-    return await dependencies.sendCodexResponsesRequest({
+    return await dependencies.sendCodexRequest({
         codexBaseUrl: config.upstream.codex_base_url,
-        requestHeaders,
+        method: request.method.toUpperCase(),
+        pathWithQuery,
+        requestHeaders: request.headers,
         accessToken,
         accountIdHeader: auth?.tokens?.account_id,
-        body: requestBody
+        body: request.body
     });
 }
 /**
@@ -85,7 +124,7 @@ async function sendWithAccount(dependencies, picked, accessToken, requestHeaders
  *
  * 业务含义：
  * 1. 默认依赖绑定真实配置、账号、状态和上游请求。
- * 2. 测试或未来扩展可注入替代依赖，避免业务重试逻辑硬绑 I/O 实现。
+ * 2. `/v1/*` 与历史 `/backend-api/codex/*` 都复用同一套账号调度、401 刷新与异常兜底语义。
  *
  * @param overrides 可选依赖覆盖项。
  * @returns 代理重试服务实例。
@@ -96,47 +135,71 @@ function createProxyRetryService(overrides) {
         loadConfig: config_1.loadConfig,
         listCandidateAccounts: scheduler_1.listCandidateAccounts,
         readAuthFile: account_store_1.readAuthFile,
-        sendCodexResponsesRequest: upstream_client_1.sendCodexResponsesRequest,
+        sendCodexRequest: upstream_client_1.sendCodexRequest,
         refreshAccountTokens: usage_sync_1.refreshAccountTokens,
         setAccountBlock: state_1.setAccountBlock,
         recordAccountScheduleSuccess: state_repository_1.recordAccountScheduleSuccess,
         ...overrides
     };
-    return {
-        async proxyResponsesWithRetry(requestHeaders, requestBody) {
-            const candidates = dependencies.listCandidateAccounts();
-            if (candidates.length === 0) {
-                return buildSendResult(503, {
+    const proxyCodexWithRetry = async (request) => {
+        const route = resolveCodexPath(request);
+        if (route.error) {
+            return route.error;
+        }
+        const candidates = dependencies.listCandidateAccounts();
+        if (candidates.length === 0) {
+            return buildSendResult(503, {
+                error: {
+                    message: (0, text_1.bi)("当前没有可用账号", "No available account"),
+                    type: "no_available_account"
+                }
+            });
+        }
+        let lastErrorPayload = {
+            error: {
+                message: (0, text_1.bi)("所有账号都请求失败", "All accounts failed"),
+                type: "all_accounts_failed"
+            }
+        };
+        let lastStatusCode = 503;
+        for (const picked of candidates) {
+            const auth = dependencies.readAuthFile(picked.account.codex_home);
+            let accessToken = auth?.tokens?.access_token;
+            if (!accessToken) {
+                markAccountFailure(dependencies, picked.account.id, "invalid_account_auth", 10 * 60);
+                lastStatusCode = 503;
+                lastErrorPayload = {
                     error: {
-                        message: (0, text_1.bi)("当前没有可用账号", "No available account"),
-                        type: "no_available_account"
+                        message: (0, text_1.bi)(`账号 ${picked.account.id} 缺少 access_token`, `Account ${picked.account.id} is missing access_token`),
+                        type: "invalid_account_auth"
                     }
-                });
+                };
+                continue;
             }
-            let lastErrorPayload = {
-                error: {
-                    message: (0, text_1.bi)("所有账号都请求失败", "All accounts failed"),
-                    type: "all_accounts_failed"
-                }
-            };
-            let lastStatusCode = 503;
-            for (const picked of candidates) {
-                const auth = dependencies.readAuthFile(picked.account.codex_home);
-                let accessToken = auth?.tokens?.access_token;
-                if (!accessToken) {
-                    markAccountFailure(dependencies, picked.account.id, "invalid_account_auth", 10 * 60);
-                    lastStatusCode = 503;
-                    lastErrorPayload = {
-                        error: {
-                            message: (0, text_1.bi)(`账号 ${picked.account.id} 缺少 access_token`, `Account ${picked.account.id} is missing access_token`),
-                            type: "invalid_account_auth"
-                        }
-                    };
+            let upstream;
+            try {
+                upstream = await sendWithAccount(dependencies, picked, accessToken, route.pathWithQuery, request);
+            }
+            catch (error) {
+                lastStatusCode = 503;
+                if ((0, upstream_error_policy_1.isNetworkUnavailableError)(error)) {
+                    lastErrorPayload = (0, upstream_error_policy_1.buildNetworkUnavailablePayload)(picked.account.id, error);
                     continue;
                 }
-                let upstream;
+                markAccountFailure(dependencies, picked.account.id, "request_failed", 60);
+                lastErrorPayload = {
+                    error: {
+                        message: `账号 ${picked.account.id} 请求上游失败: ${error instanceof Error ? error.message : String(error)}`,
+                        type: "account_request_failed"
+                    }
+                };
+                continue;
+            }
+            if (upstream.statusCode === 401) {
                 try {
-                    upstream = await sendWithAccount(dependencies, picked, accessToken, requestHeaders, requestBody);
+                    const refreshed = await dependencies.refreshAccountTokens(picked.account.id);
+                    accessToken = refreshed.tokens?.access_token ?? accessToken;
+                    upstream = await sendWithAccount(dependencies, picked, accessToken, route.pathWithQuery, request);
                 }
                 catch (error) {
                     lastStatusCode = 503;
@@ -144,94 +207,82 @@ function createProxyRetryService(overrides) {
                         lastErrorPayload = (0, upstream_error_policy_1.buildNetworkUnavailablePayload)(picked.account.id, error);
                         continue;
                     }
-                    markAccountFailure(dependencies, picked.account.id, "request_failed", 60);
+                    markAccountFailure(dependencies, picked.account.id, "token_refresh_failed", 10 * 60);
                     lastErrorPayload = {
                         error: {
-                            message: `账号 ${picked.account.id} 请求上游失败: ${error instanceof Error ? error.message : String(error)}`,
-                            type: "account_request_failed"
+                            message: `账号 ${picked.account.id} 刷新 token 失败: ${error instanceof Error ? error.message : String(error)}`,
+                            type: "account_token_refresh_failed"
                         }
                     };
                     continue;
                 }
-                if (upstream.statusCode === 401) {
-                    try {
-                        const refreshed = await dependencies.refreshAccountTokens(picked.account.id);
-                        accessToken = refreshed.tokens?.access_token ?? accessToken;
-                        upstream = await sendWithAccount(dependencies, picked, accessToken, requestHeaders, requestBody);
-                    }
-                    catch (error) {
-                        lastStatusCode = 503;
-                        if ((0, upstream_error_policy_1.isNetworkUnavailableError)(error)) {
-                            lastErrorPayload = (0, upstream_error_policy_1.buildNetworkUnavailablePayload)(picked.account.id, error);
-                            continue;
-                        }
-                        markAccountFailure(dependencies, picked.account.id, "token_refresh_failed", 10 * 60);
-                        lastErrorPayload = {
-                            error: {
-                                message: `账号 ${picked.account.id} 刷新 token 失败: ${error instanceof Error ? error.message : String(error)}`,
-                                type: "account_token_refresh_failed"
-                            }
-                        };
-                        continue;
+            }
+            const responseHeaders = pickResponseHeaders(upstream.headers);
+            if (upstream.statusCode === 429 || upstream.statusCode === 403) {
+                const errorText = await upstream.body.text();
+                const block = (0, upstream_error_policy_1.resolveBlockWindow)(picked, errorText);
+                dependencies.setAccountBlock(picked.account.id, block.until, block.reason);
+                lastStatusCode = upstream.statusCode;
+                lastErrorPayload = {
+                    error: {
+                        message: `账号 ${picked.account.id} 受限: ${errorText}`,
+                        type: "account_rate_limited"
                     }
-                }
-                const responseHeaders = pickResponseHeaders(upstream.headers);
-                if (upstream.statusCode === 429 || upstream.statusCode === 403) {
-                    const errorText = await upstream.body.text();
+                };
+                continue;
+            }
+            if (upstream.statusCode >= 400) {
+                const errorText = await upstream.body.text();
+                if ((0, upstream_error_policy_1.isUsageLimitErrorText)(errorText)) {
                     const block = (0, upstream_error_policy_1.resolveBlockWindow)(picked, errorText);
                     dependencies.setAccountBlock(picked.account.id, block.until, block.reason);
                     lastStatusCode = upstream.statusCode;
                     lastErrorPayload = {
                         error: {
-                            message: `账号 ${picked.account.id} 受限: ${errorText}`,
-                            type: "account_rate_limited"
+                            message: `账号 ${picked.account.id} 命中额度限制: ${errorText}`,
+                            type: "account_usage_limited"
                         }
                     };
                     continue;
                 }
-                if (upstream.statusCode >= 400) {
-                    const errorText = await upstream.body.text();
-                    if ((0, upstream_error_policy_1.isUsageLimitErrorText)(errorText)) {
-                        const block = (0, upstream_error_policy_1.resolveBlockWindow)(picked, errorText);
-                        dependencies.setAccountBlock(picked.account.id, block.until, block.reason);
-                        lastStatusCode = upstream.statusCode;
-                        lastErrorPayload = {
-                            error: {
-                                message: `账号 ${picked.account.id} 命中额度限制: ${errorText}`,
-                                type: "account_usage_limited"
-                            }
-                        };
-                        continue;
-                    }
-                    if (upstream.statusCode >= 500) {
-                        markAccountFailure(dependencies, picked.account.id, "upstream_5xx", 60);
-                        lastStatusCode = upstream.statusCode;
-                        lastErrorPayload = {
-                            error: {
-                                message: `账号 ${picked.account.id} 上游异常: ${errorText}`,
-                                type: "account_upstream_failed"
-                            }
-                        };
-                        continue;
-                    }
-                    return buildSendResult(upstream.statusCode, errorText, {
-                        "content-type": responseHeaders["content-type"] ?? "application/json",
-                        ...responseHeaders
-                    });
+                if (upstream.statusCode >= 500) {
+                    markAccountFailure(dependencies, picked.account.id, "upstream_5xx", 60);
+                    lastStatusCode = upstream.statusCode;
+                    lastErrorPayload = {
+                        error: {
+                            message: `账号 ${picked.account.id} 上游异常: ${errorText}`,
+                            type: "account_upstream_failed"
+                        }
+                    };
+                    continue;
                 }
-                dependencies.recordAccountScheduleSuccess(picked.account.id);
-                return {
-                    type: "proxy",
-                    statusCode: upstream.statusCode,
-                    headers: {
-                        ...responseHeaders,
-                        connection: "keep-alive"
-                    },
-                    body: upstream.body
-                };
+                return buildSendResult(upstream.statusCode, errorText, {
+                    "content-type": responseHeaders["content-type"] ?? "application/json",
+                    ...responseHeaders
+                });
             }
-            return buildSendResult(lastStatusCode, lastErrorPayload);
+            dependencies.recordAccountScheduleSuccess(picked.account.id);
+            return {
+                type: "proxy",
+                statusCode: upstream.statusCode,
+                headers: {
+                    ...responseHeaders,
+                    connection: "keep-alive"
+                },
+                body: upstream.body
+            };
         }
+        return buildSendResult(lastStatusCode, lastErrorPayload);
+    };
+    const proxyResponsesWithRetry = async (requestHeaders, requestBody) => await proxyCodexWithRetry({
+        method: "POST",
+        url: "/v1/responses",
+        headers: requestHeaders,
+        body: requestBody
+    });
+    return {
+        proxyCodexWithRetry,
+        proxyResponsesWithRetry
     };
 }
-exports.proxyResponsesWithRetry = createProxyRetryService().proxyResponsesWithRetry;
+_a = createProxyRetryService(), exports.proxyCodexWithRetry = _a.proxyCodexWithRetry, exports.proxyResponsesWithRetry = _a.proxyResponsesWithRetry;

package/dist/server.js

@@ -14,12 +14,15 @@ const usage_sync_1 = require("./usage-sync");
 /**
  * 读取代理请求的原始 body 字节，供多账号重试时重复发送同一份载荷。
  *
- * @param stream 客户端发到代理路由的原始可读流。
+ * @param stream 客户端发到代理路由的原始可读流；无 body 时允许为空。
  * @returns 完整请求体的 Buffer；空请求体时返回空 Buffer。
  * @throws 当读取流失败时抛出底层 I/O 错误。
  */
 async function readRawRequestBody(stream) {
     const chunks = [];
+    if (!stream) {
+        return Buffer.alloc(0);
+    }
     for await (const chunk of stream) {
         // 统一转成 Buffer，避免不同 chunk 类型在后续重发时出现编码歧义。
         chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -86,9 +89,14 @@ async function startServer(port) {
             selected: (0, scheduler_1.pickBestAccount)()
         };
     });
-    const proxyHandler = async (requestBodyStream, requestHeaders, reply) => {
-        const requestBody = await readRawRequestBody(requestBodyStream);
-        const result = await (0, proxy_retry_service_1.proxyResponsesWithRetry)(requestHeaders, requestBody);
+    const codexProxyHandler = async (request, reply) => {
+        const requestBody = await readRawRequestBody(request.body);
+        const result = await (0, proxy_retry_service_1.proxyCodexWithRetry)({
+            method: request.method,
+            url: request.url,
+            headers: request.headers,
+            body: requestBody
+        });
         if (result.type === "send") {
             reply.code(result.statusCode);
             for (const [headerName, headerValue] of Object.entries(result.headers ?? {})) {
@@ -123,11 +131,33 @@ async function startServer(port) {
         proxyApp.addContentTypeParser("*", (request, payload, done) => {
             done(null, payload);
         });
-        proxyApp.post("/v1/responses", { bodyLimit: Number.MAX_SAFE_INTEGER }, async (request, reply) => {
-            await proxyHandler(request.body, request.headers, reply);
+        proxyApp.route({
+            method: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+            url: "/v1/*",
+            bodyLimit: Number.MAX_SAFE_INTEGER,
+            handler: async (request, reply) => {
+                const body = request.body;
+                await codexProxyHandler({
+                    method: request.method,
+                    url: request.url,
+                    headers: request.headers,
+                    body
+                }, reply);
+            }
         });
-        proxyApp.post("/backend-api/codex/responses", { bodyLimit: Number.MAX_SAFE_INTEGER }, async (request, reply) => {
-            await proxyHandler(request.body, request.headers, reply);
+        proxyApp.route({
+            method: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+            url: "/backend-api/codex/*",
+            bodyLimit: Number.MAX_SAFE_INTEGER,
+            handler: async (request, reply) => {
+                const body = request.body;
+                await codexProxyHandler({
+                    method: request.method,
+                    url: request.url,
+                    headers: request.headers,
+                    body
+                }, reply);
+            }
         });
         proxyApp.route({
             method: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],

package/dist/upstream-client.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildUpstreamHeaders = buildUpstreamHeaders;
+exports.sendCodexRequest = sendCodexRequest;
 exports.sendCodexResponsesRequest = sendCodexResponsesRequest;
 exports.buildChatGptBackendHeaders = buildChatGptBackendHeaders;
 exports.sendChatGptBackendRequest = sendChatGptBackendRequest;
@@ -38,13 +39,38 @@ function buildUpstreamHeaders(requestHeaders, accessToken, bodyLength, accountId
     if (!headers.accept) {
         headers.accept = "text/event-stream, application/json";
     }
-    headers["content-length"] = String(bodyLength);
+    if (typeof bodyLength === "number") {
+        headers["content-length"] = String(bodyLength);
+    }
     headers["user-agent"] = "codex-slot/0.1.1";
     if (accountIdHeader) {
         headers["chatgpt-account-id"] = accountIdHeader;
     }
     return headers;
 }
+/**
+ * 向 Codex-compatible 上游发送一次通用请求。
+ *
+ * 业务含义：
+ * 1. 本地 `/v1/*` 或旧 `/backend-api/codex/*` 路由都应复用同一条上游转发逻辑，避免再按接口逐个补洞。
+ * 2. 路由后缀与 query 原样拼接到 `codexBaseUrl` 后，仅由 cslot 负责替换官方 access token 与账号头。
+ *
+ * @param options 上游请求参数，包含方法、目标 path/query、原始请求头以及可选 body。
+ * @returns undici 上游响应对象。
+ * @throws 当网络层或 undici 请求失败时透传底层异常。
+ */
+async function sendCodexRequest(options) {
+    const baseUrl = options.codexBaseUrl.replace(/\/+$/, "");
+    const pathWithQuery = options.pathWithQuery.startsWith("/")
+        ? options.pathWithQuery
+        : `/${options.pathWithQuery}`;
+    const bodyLength = options.body && options.body.length > 0 ? options.body.length : undefined;
+    return await (0, undici_1.request)(`${baseUrl}${pathWithQuery}`, {
+        method: options.method,
+        headers: buildUpstreamHeaders(options.requestHeaders, options.accessToken, bodyLength, options.accountIdHeader),
+        body: options.body && options.body.length > 0 ? options.body : undefined
+    });
+}
 /**
  * 向 Codex responses 上游发送一次请求。
  *
@@ -57,9 +83,13 @@ function buildUpstreamHeaders(requestHeaders, accessToken, bodyLength, accountId
  * @throws 当网络层或 undici 请求失败时透传底层异常。
  */
 async function sendCodexResponsesRequest(options) {
-    return await (0, undici_1.request)(`${options.codexBaseUrl}/responses`, {
+    return await sendCodexRequest({
+        codexBaseUrl: options.codexBaseUrl,
         method: "POST",
-        headers: buildUpstreamHeaders(options.requestHeaders, options.accessToken, options.body.length, options.accountIdHeader),
+        pathWithQuery: "/responses",
+        requestHeaders: options.requestHeaders,
+        accessToken: options.accessToken,
+        accountIdHeader: options.accountIdHeader,
         body: options.body
     });
 }

package/package.json

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