codex-slot 0.1.26 → 0.1.27

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.27",
   "description": "本地 Codex 多账号切换与状态管理工具",
   "type": "commonjs",
   "main": "dist/cli.js",