codex-slot 0.1.25 → 0.1.27

package/dist/app/service-lifecycle-service.js

@@ -4,6 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRunningPid = getRunningPid;
+exports.buildLaunchAgentPlist = buildLaunchAgentPlist;
+exports.resolveServiceManagerKind = resolveServiceManagerKind;
+exports.buildSystemdUserUnit = buildSystemdUserUnit;
 exports.startManagedService = startManagedService;
 exports.stopManagedService = stopManagedService;
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -20,6 +23,7 @@ const cli_helpers_1 = require("../cli-helpers");
 const config_1 = require("../config");
 const STARTUP_POLL_INTERVAL_MS = 100;
 const STARTUP_TIMEOUT_MS = 5000;
+const LAUNCH_AGENT_LABEL_PREFIX = "com.openxiaobu.cslot";
 /**
  * 休眠指定毫秒数，供启动轮询流程复用。
  *
@@ -75,6 +79,361 @@ function resolveServeEntrypoint() {
         args: [`${serveBasePath}.js`]
     };
 }
+/**
+ * 基于当前 HOME 目录生成稳定的 launchd label，避免测试隔离 HOME 与真实 HOME 互相冲突。
+ *
+ * @returns 当前 HOME 对应的 launchd label。
+ * @throws 无显式抛出。
+ */
+function getLaunchAgentLabel() {
+    const home = (0, config_1.getUserHomeDir)();
+    let hash = 2166136261;
+    for (const character of home) {
+        hash ^= character.charCodeAt(0);
+        hash = Math.imul(hash, 16777619);
+    }
+    return `${LAUNCH_AGENT_LABEL_PREFIX}.${(hash >>> 0).toString(16)}`;
+}
+/**
+ * 返回当前 HOME 对应的 LaunchAgents plist 路径，并确保父目录存在。
+ *
+ * @returns launchd plist 绝对路径。
+ * @throws 当目录创建失败时抛出文件系统错误。
+ */
+function getLaunchAgentPlistPath() {
+    const launchAgentsDir = node_path_1.default.join((0, config_1.getUserHomeDir)(), "Library", "LaunchAgents");
+    node_fs_1.default.mkdirSync(launchAgentsDir, { recursive: true });
+    return node_path_1.default.join(launchAgentsDir, `${getLaunchAgentLabel()}.plist`);
+}
+/**
+ * 对 XML 文本做最小转义，避免命令参数与日志路径写入 plist 时破坏结构。
+ *
+ * @param value 待写入 plist 的原始文本。
+ * @returns 完成 XML 转义后的文本。
+ * @throws 无显式抛出。
+ */
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll("\"", "&quot;")
+        .replaceAll("'", "&apos;");
+}
+/**
+ * 生成 launchd plist 内容，使 cslot 服务具备开机自启与异常退出自动拉起能力。
+ *
+ * @param command 启动服务使用的绝对命令路径。
+ * @param args 命令参数列表。
+ * @param logPath 标准输出与错误输出写入的日志路径。
+ * @returns 可直接写入磁盘的 plist 文本。
+ * @throws 无显式抛出。
+ */
+function buildLaunchAgentPlist(command, args, logPath) {
+    const programArguments = [command, ...args].map((item) => `      <string>${escapeXml(item)}</string>`).join("\n");
+    const home = escapeXml((0, config_1.getUserHomeDir)());
+    const label = escapeXml(getLaunchAgentLabel());
+    const escapedLogPath = escapeXml(logPath);
+    return [
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
+        "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">",
+        "<plist version=\"1.0\">",
+        "<dict>",
+        "  <key>Label</key>",
+        `  <string>${label}</string>`,
+        "  <key>ProgramArguments</key>",
+        "  <array>",
+        programArguments,
+        "  </array>",
+        "  <key>RunAtLoad</key>",
+        "  <true/>",
+        "  <key>KeepAlive</key>",
+        "  <true/>",
+        "  <key>EnvironmentVariables</key>",
+        "  <dict>",
+        "    <key>HOME</key>",
+        `    <string>${home}</string>`,
+        "  </dict>",
+        "  <key>StandardOutPath</key>",
+        `  <string>${escapedLogPath}</string>`,
+        "  <key>StandardErrorPath</key>",
+        `  <string>${escapedLogPath}</string>`,
+        "</dict>",
+        "</plist>",
+        ""
+    ].join("\n");
+}
+/**
+ * 判断当前环境是否应启用 launchd 托管。
+ *
+ * @returns macOS 且未显式禁用 launchd 时返回 `true`，否则返回 `false`。
+ * @throws 无显式抛出。
+ */
+function shouldUseLaunchd() {
+    return process.platform === "darwin" && process.env.CSLOT_DISABLE_LAUNCHD !== "1";
+}
+/**
+ * 判断当前 Linux 环境是否应使用 systemd user service 托管。
+ *
+ * @returns Linux 且未显式禁用 systemd 托管时返回 `true`，否则返回 `false`。
+ * @throws 无显式抛出。
+ */
+function shouldUseSystemdUser() {
+    return process.platform === "linux" && process.env.CSLOT_DISABLE_SYSTEMD !== "1";
+}
+/**
+ * 解析当前平台应使用的后台服务托管方式。
+ *
+ * @returns 当前平台对应的服务管理器类型。
+ * @throws 当 Linux 期望使用 systemd 但本机缺少 `systemctl` 时抛出异常。
+ */
+function resolveServiceManagerKind() {
+    if (shouldUseLaunchd()) {
+        return "launchd";
+    }
+    if (shouldUseSystemdUser()) {
+        try {
+            (0, node_child_process_1.execFileSync)("systemctl", ["--user", "--version"], {
+                stdio: ["ignore", "ignore", "ignore"]
+            });
+        }
+        catch {
+            throw new Error("当前 Linux 环境缺少 systemd --user，无法提供自动拉起与开机自启。请安装 systemd user service，或显式设置 CSLOT_DISABLE_SYSTEMD=1 回退到 detached 模式。");
+        }
+        return "systemd-user";
+    }
+    return "detached";
+}
+/**
+ * 返回当前用户的 launchd domain，供 `launchctl bootstrap/bootout` 复用。
+ *
+ * @returns 类似 `gui/501` 的 domain 字符串。
+ * @throws 当当前进程无法获取 uid 时抛出异常。
+ */
+function getLaunchctlDomain() {
+    if (typeof process.getuid !== "function") {
+        throw new Error("当前平台不支持 launchctl user domain");
+    }
+    return `gui/${process.getuid()}`;
+}
+/**
+ * 返回 systemd user service 的 unit 名称，按 HOME 做稳定区分，避免测试与真实环境互串。
+ *
+ * @returns 当前 HOME 对应的 systemd unit 文件名。
+ * @throws 无显式抛出。
+ */
+function getSystemdUserUnitName() {
+    return `${getLaunchAgentLabel().replaceAll(".", "-")}.service`;
+}
+/**
+ * 返回 systemd user service unit 文件路径，并确保目录存在。
+ *
+ * @returns systemd user unit 绝对路径。
+ * @throws 当目录创建失败时抛出文件系统错误。
+ */
+function getSystemdUserUnitPath() {
+    const unitDir = node_path_1.default.join((0, config_1.getUserHomeDir)(), ".config", "systemd", "user");
+    node_fs_1.default.mkdirSync(unitDir, { recursive: true });
+    return node_path_1.default.join(unitDir, getSystemdUserUnitName());
+}
+/**
+ * 对 systemd Environment 值做最小转义，避免空格或双引号破坏 unit 文件语义。
+ *
+ * @param value Environment 原始值。
+ * @returns 已转义的值文本。
+ * @throws 无显式抛出。
+ */
+function escapeSystemdEnvironmentValue(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
+}
+/**
+ * 对 systemd ExecStart 参数做 shell 风格转义，确保路径和参数可被 systemd 正确拆分。
+ *
+ * @param value ExecStart 单个参数文本。
+ * @returns 安全可写入 unit 的参数文本。
+ * @throws 无显式抛出。
+ */
+function quoteSystemdExecArgument(value) {
+    return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+/**
+ * 生成 systemd --user service unit，使 cslot 在 Linux 下具备用户级开机自启与异常退出自动重启能力。
+ *
+ * @param command 启动服务使用的绝对命令路径。
+ * @param args 命令参数列表。
+ * @param logPath 服务日志路径。
+ * @returns 可直接写入 systemd user unit 的文本。
+ * @throws 无显式抛出。
+ */
+function buildSystemdUserUnit(command, args, logPath) {
+    const execStart = [command, ...args].map(quoteSystemdExecArgument).join(" ");
+    const home = escapeSystemdEnvironmentValue((0, config_1.getUserHomeDir)());
+    const safeLogPath = logPath.replaceAll("\\", "\\\\").replaceAll("%", "%%");
+    return [
+        "[Unit]",
+        "Description=cslot managed local proxy",
+        "After=network-online.target",
+        "Wants=network-online.target",
+        "",
+        "[Service]",
+        "Type=simple",
+        `Environment=HOME="${home}"`,
+        `ExecStart=${execStart}`,
+        "Restart=always",
+        "RestartSec=1",
+        `StandardOutput=append:${safeLogPath}`,
+        `StandardError=append:${safeLogPath}`,
+        "",
+        "[Install]",
+        "WantedBy=default.target",
+        ""
+    ].join("\n");
+}
+/**
+ * 执行一次 systemctl --user 命令，并在允许的退出码范围内按幂等成功处理。
+ *
+ * @param args systemctl 参数列表。
+ * @param allowedStatuses 允许按成功处理的退出码集合。
+ * @returns 标准输出文本。
+ * @throws 当命令失败且退出码不在允许列表中时抛出异常。
+ */
+function runSystemctlUser(args, allowedStatuses = []) {
+    try {
+        return (0, node_child_process_1.execFileSync)("systemctl", ["--user", ...args], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+    }
+    catch (error) {
+        const status = typeof error === "object" && error && "status" in error ? Number(error.status) : null;
+        if (status !== null && allowedStatuses.includes(status)) {
+            return "";
+        }
+        const stderr = typeof error === "object" && error && "stderr" in error && typeof error.stderr === "string"
+            ? error.stderr.trim()
+            : "";
+        const message = stderr || (error instanceof Error ? error.message : String(error));
+        throw new Error(`systemctl --user ${args.join(" ")} 失败: ${message}`);
+    }
+}
+/**
+ * 启动或重载 systemd --user 托管的 cslot 服务。
+ *
+ * @param port 最终启动端口。
+ * @param logPath 服务日志路径。
+ * @returns 当前 systemd 托管实例的 PID。
+ * @throws 当 unit 写入、systemctl 调用或服务就绪检查失败时抛出异常。
+ */
+async function startManagedServiceWithSystemdUser(port, logPath) {
+    const serveEntrypoint = resolveServeEntrypoint();
+    const unitPath = getSystemdUserUnitPath();
+    const unitName = getSystemdUserUnitName();
+    const unit = buildSystemdUserUnit(serveEntrypoint.command, [...serveEntrypoint.args, "--port", String(port)], logPath);
+    node_fs_1.default.writeFileSync(unitPath, unit, "utf8");
+    runSystemctlUser(["daemon-reload"]);
+    runSystemctlUser(["enable", "--now", unitName]);
+    return await waitForManagedServicePid();
+}
+/**
+ * 停止并卸载 systemd --user 托管的 cslot 服务，同时清理本地 unit 工件。
+ *
+ * @returns 停止前记录到的 PID；若当时没有可见运行 PID 则返回 `null`。
+ * @throws 当 systemctl 卸载或清理失败时抛出异常。
+ */
+function stopManagedServiceWithSystemdUser() {
+    const pid = getRunningPid();
+    const unitName = getSystemdUserUnitName();
+    const unitPath = getSystemdUserUnitPath();
+    runSystemctlUser(["disable", "--now", unitName], [1, 5]);
+    node_fs_1.default.rmSync(unitPath, { force: true });
+    runSystemctlUser(["daemon-reload"]);
+    runSystemctlUser(["reset-failed", unitName], [1, 5]);
+    node_fs_1.default.rmSync((0, config_1.getPidPath)(), { force: true });
+    return pid;
+}
+/**
+ * 执行一次 launchctl 命令，并在允许的失败码内按幂等处理。
+ *
+ * @param args launchctl 参数列表。
+ * @param allowedStatuses 允许视为成功的退出码集合。
+ * @returns 标准输出文本。
+ * @throws 当命令执行失败且退出码不在允许集合中时抛出异常。
+ */
+function runLaunchctl(args, allowedStatuses = []) {
+    try {
+        return (0, node_child_process_1.execFileSync)("launchctl", args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+    }
+    catch (error) {
+        const status = typeof error === "object" && error && "status" in error ? Number(error.status) : null;
+        if (status !== null && allowedStatuses.includes(status)) {
+            return "";
+        }
+        const stderr = typeof error === "object" && error && "stderr" in error && typeof error.stderr === "string"
+            ? error.stderr.trim()
+            : "";
+        const message = stderr || (error instanceof Error ? error.message : String(error));
+        throw new Error(`launchctl ${args.join(" ")} 失败: ${message}`);
+    }
+}
+/**
+ * 等待服务进程把自己的 PID 写入本地状态文件，兼容 launchd 拉起的非子进程模型。
+ *
+ * @param timeoutMs 等待超时时间，单位毫秒。
+ * @returns Promise，成功时返回当前运行中的 PID。
+ * @throws 当超时后仍未拿到有效 PID 时抛出异常。
+ */
+async function waitForManagedServicePid(timeoutMs = STARTUP_TIMEOUT_MS) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const pid = getRunningPid();
+        if (pid) {
+            return pid;
+        }
+        await sleep(STARTUP_POLL_INTERVAL_MS);
+    }
+    throw new Error(`后台服务启动超时，未在 ${timeoutMs}ms 内写入有效 PID`);
+}
+/**
+ * 启动或重载 launchd 托管的 cslot 服务。
+ *
+ * @param port 最终启动端口。
+ * @param logPath 服务日志路径。
+ * @returns 当前 launchd 托管实例的 PID。
+ * @throws 当 plist 写入、launchctl 调用或服务就绪检查失败时抛出异常。
+ */
+async function startManagedServiceWithLaunchd(port, logPath) {
+    const serveEntrypoint = resolveServeEntrypoint();
+    const plistPath = getLaunchAgentPlistPath();
+    const domain = getLaunchctlDomain();
+    const label = getLaunchAgentLabel();
+    const plist = buildLaunchAgentPlist(serveEntrypoint.command, [...serveEntrypoint.args, "--port", String(port)], logPath);
+    node_fs_1.default.writeFileSync(plistPath, plist, "utf8");
+    // 先卸载旧 job，再用最新配置重载，避免端口或命令参数更新后仍复用旧定义。
+    runLaunchctl(["bootout", domain, plistPath], [3, 5, 36, 64, 113]);
+    runLaunchctl(["bootstrap", domain, plistPath]);
+    runLaunchctl(["enable", `${domain}/${label}`], [3, 5, 64, 113]);
+    runLaunchctl(["kickstart", "-k", `${domain}/${label}`]);
+    const pid = await waitForManagedServicePid();
+    return pid;
+}
+/**
+ * 停止并卸载 launchd 托管的 cslot 服务，同时清理本地 plist 工件。
+ *
+ * @returns 停止前记录到的 PID；若当时没有可见运行 PID 则返回 `null`。
+ * @throws 当 launchctl 卸载失败时抛出异常。
+ */
+function stopManagedServiceWithLaunchd() {
+    const pid = getRunningPid();
+    const plistPath = getLaunchAgentPlistPath();
+    const domain = getLaunchctlDomain();
+    runLaunchctl(["bootout", domain, plistPath], [3, 5, 36, 64, 113]);
+    node_fs_1.default.rmSync(plistPath, { force: true });
+    node_fs_1.default.rmSync((0, config_1.getPidPath)(), { force: true });
+    return pid;
+}
 /**
  * 检查指定地址与端口当前是否可绑定，用于启动前规避端口冲突。
  *
@@ -165,6 +524,18 @@ function rollbackFailedStart(pid, previousConfig) {
         }
     }
     node_fs_1.default.rmSync((0, config_1.getPidPath)(), { force: true });
+    try {
+        const manager = resolveServiceManagerKind();
+        if (manager === "launchd") {
+            stopManagedServiceWithLaunchd();
+        }
+        else if (manager === "systemd-user") {
+            stopManagedServiceWithSystemdUser();
+        }
+    }
+    catch {
+        // 回滚阶段以尽力清理为主，不覆盖原始启动异常。
+    }
     (0, config_1.saveConfig)(previousConfig);
     (0, codex_config_1.deactivateManagedCodexConfig)();
     (0, codex_auth_1.deactivateManagedCodexAuth)();
@@ -255,6 +626,7 @@ async function startManagedService(portOverride) {
     const config = (0, config_1.loadConfig)();
     const previousConfig = structuredClone(config);
     const { port, autoSwitched } = await resolveStartPort(config.server.host, portOverride);
+    const manager = resolveServiceManagerKind();
     const runningPid = getRunningPid();
     if (runningPid) {
         return {
@@ -262,7 +634,8 @@ async function startManagedService(portOverride) {
             pid: runningPid,
             port: config.server.port,
             logPath: (0, config_1.getServiceLogPath)(),
-            autoSwitched: false
+            autoSwitched: false,
+            manager
         };
     }
     if (config.server.port !== port) {
@@ -272,21 +645,40 @@ async function startManagedService(portOverride) {
     (0, codex_config_1.applyManagedCodexConfig)(undefined, { config });
     applyManagedAuthIfPossible();
     const logPath = (0, config_1.getServiceLogPath)();
-    const logFd = node_fs_1.default.openSync(logPath, "a");
-    const serveEntrypoint = resolveServeEntrypoint();
-    const child = (0, node_child_process_1.spawn)(serveEntrypoint.command, [...serveEntrypoint.args, "--port", String(port)], {
-        detached: true,
-        stdio: ["ignore", logFd, logFd]
-    });
-    const childPid = child.pid ?? null;
-    child.unref();
-    if (!childPid) {
+    let childPid = null;
+    if (manager === "launchd") {
+        try {
+            childPid = await startManagedServiceWithLaunchd(port, logPath);
+        }
+        catch (error) {
+            rollbackFailedStart(null, previousConfig);
+            throw error;
+        }
+    }
+    else if (manager === "systemd-user") {
+        try {
+            childPid = await startManagedServiceWithSystemdUser(port, logPath);
+        }
+        catch (error) {
+            rollbackFailedStart(null, previousConfig);
+            throw error;
+        }
+    }
+    else {
+        const logFd = node_fs_1.default.openSync(logPath, "a");
+        const serveEntrypoint = resolveServeEntrypoint();
+        const child = (0, node_child_process_1.spawn)(serveEntrypoint.command, [...serveEntrypoint.args, "--port", String(port)], {
+            detached: true,
+            stdio: ["ignore", logFd, logFd]
+        });
+        childPid = child.pid ?? null;
+        child.unref();
         node_fs_1.default.closeSync(logFd);
-        rollbackFailedStart(null, previousConfig);
-        throw new Error("后台服务启动失败，未获取到有效子进程 PID");
+        if (!childPid) {
+            rollbackFailedStart(null, previousConfig);
+            throw new Error("后台服务启动失败，未获取到有效子进程 PID");
+        }
     }
-    node_fs_1.default.writeFileSync((0, config_1.getPidPath)(), `${childPid}\n`, "utf8");
-    node_fs_1.default.closeSync(logFd);
     try {
         await waitForManagedServiceReady(config.server.host, port, childPid);
     }
@@ -299,7 +691,8 @@ async function startManagedService(portOverride) {
         pid: childPid,
         port,
         logPath,
-        autoSwitched
+        autoSwitched,
+        manager
     };
 }
 /**
@@ -309,14 +702,25 @@ async function startManagedService(portOverride) {
  * @throws 当进程终止失败时透传底层异常。
  */
 function stopManagedService() {
+    const manager = resolveServiceManagerKind();
+    const hasLaunchAgent = manager === "launchd" && node_fs_1.default.existsSync(getLaunchAgentPlistPath());
+    const hasSystemdUnit = manager === "systemd-user" && node_fs_1.default.existsSync(getSystemdUserUnitPath());
     const pid = getRunningPid();
-    if (!pid) {
+    if (!pid && !hasLaunchAgent && !hasSystemdUnit) {
         (0, codex_config_1.deactivateManagedCodexConfig)();
         (0, codex_auth_1.deactivateManagedCodexAuth)();
         return { stoppedPid: null };
     }
-    process.kill(pid, "SIGTERM");
-    node_fs_1.default.rmSync((0, config_1.getPidPath)(), { force: true });
+    if (hasLaunchAgent) {
+        stopManagedServiceWithLaunchd();
+    }
+    else if (hasSystemdUnit) {
+        stopManagedServiceWithSystemdUser();
+    }
+    else if (pid) {
+        process.kill(pid, "SIGTERM");
+        node_fs_1.default.rmSync((0, config_1.getPidPath)(), { force: true });
+    }
     (0, codex_config_1.deactivateManagedCodexConfig)();
     (0, codex_auth_1.deactivateManagedCodexAuth)();
     return { stoppedPid: pid };

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/serve.js

@@ -1,9 +1,60 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
 const config_1 = require("./config");
 const server_1 = require("./server");
 const text_1 = require("./text");
+/**
+ * 将当前服务进程 PID 持久化到本地状态文件，供 `cslot stop` 与健康检查流程复用。
+ *
+ * @returns 无返回值。
+ * @throws 当 PID 文件写入失败时抛出文件系统错误。
+ */
+function writeCurrentPid() {
+    node_fs_1.default.writeFileSync((0, config_1.getPidPath)(), `${process.pid}\n`, "utf8");
+}
+/**
+ * 按幂等方式清理当前服务进程留下的 PID 文件，避免异常退出后残留脏状态。
+ *
+ * @returns 无返回值。
+ * @throws 无显式抛出。
+ */
+function cleanupPidFile() {
+    try {
+        const pidPath = (0, config_1.getPidPath)();
+        if (!node_fs_1.default.existsSync(pidPath)) {
+            return;
+        }
+        const raw = node_fs_1.default.readFileSync(pidPath, "utf8").trim();
+        if (Number(raw) === process.pid) {
+            node_fs_1.default.rmSync(pidPath, { force: true });
+        }
+    }
+    catch {
+        // 退出清理阶段以幂等为主，不阻塞真实退出流程。
+    }
+}
+/**
+ * 注册服务进程退出时的 PID 清理逻辑，兼容正常停止与 launchd 重启场景。
+ *
+ * @returns 无返回值。
+ * @throws 无显式抛出。
+ */
+function registerPidCleanupHandlers() {
+    process.once("exit", cleanupPidFile);
+    process.once("SIGINT", () => {
+        cleanupPidFile();
+        process.exit(0);
+    });
+    process.once("SIGTERM", () => {
+        cleanupPidFile();
+        process.exit(0);
+    });
+}
 /**
  * 后台服务进程入口。
  *
@@ -16,9 +67,12 @@ async function main() {
     const port = portArgIndex >= 0 && process.argv[portArgIndex + 1]
         ? Number(process.argv[portArgIndex + 1])
         : config.server.port;
+    writeCurrentPid();
+    registerPidCleanupHandlers();
     await (0, server_1.startServer)(port);
 }
 void main().catch((error) => {
+    cleanupPidFile();
     const message = error instanceof Error ? error.message : String(error);
     console.error((0, text_1.bi)(`cslot service 启动失败: ${message}`, `cslot service failed to start: ${message}`));
     process.exit(1);

package/dist/server.js

@@ -14,18 +14,50 @@ 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));
     }
     return Buffer.concat(chunks);
 }
+/**
+ * 将上游响应体安全地透传给已 hijack 的本地响应。
+ *
+ * 业务含义：
+ * 1. 一旦开始写出上游 header，就不能再把异常抛回 Fastify 默认错误处理器。
+ * 2. 上游流中途断开或客户端提前关闭时，只终止当前连接，避免整个 cslot 进程崩溃。
+ *
+ * @param reply 当前请求对应的 Fastify reply。
+ * @param result 已成功拿到响应头的上游代理结果。
+ * @returns Promise，流复制结束或被安全终止后返回。
+ * @throws 无显式抛出；异常会被当前方法内部吞掉并转成连接销毁。
+ */
+async function streamProxyResponse(reply, result) {
+    reply.hijack();
+    reply.raw.writeHead(result.statusCode, result.headers);
+    try {
+        for await (const chunk of result.body) {
+            reply.raw.write(chunk);
+        }
+        reply.raw.end();
+    }
+    catch (error) {
+        console.error("cslot proxy stream aborted", error);
+        // 响应已开始输出，此时只能销毁当前连接，不能再交给 Fastify 二次写 header。
+        if (!reply.raw.destroyed) {
+            reply.raw.destroy?.(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+}
 /**
  * 启动一个极轻量本地服务，供后续接入代理或脚本化查询使用。
  *
@@ -57,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 ?? {})) {
@@ -68,12 +105,7 @@ async function startServer(port) {
             reply.send(result.payload);
             return;
         }
-        reply.hijack();
-        reply.raw.writeHead(result.statusCode, result.headers);
-        for await (const chunk of result.body) {
-            reply.raw.write(chunk);
-        }
-        reply.raw.end();
+        await streamProxyResponse(reply, result);
     };
     const backendProxyHandler = async (request, reply) => {
         const requestBody = request.body ? await readRawRequestBody(request.body) : undefined;
@@ -91,12 +123,7 @@ async function startServer(port) {
             reply.send(result.payload);
             return;
         }
-        reply.hijack();
-        reply.raw.writeHead(result.statusCode, result.headers);
-        for await (const chunk of result.body) {
-            reply.raw.write(chunk);
-        }
-        reply.raw.end();
+        await streamProxyResponse(reply, result);
     };
     await app.register(async (proxyApp) => {
         // 代理路由需要原样透传 body，不能在本地先做 JSON 解析与大小限制拦截。
@@ -104,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/service-control.js

@@ -5,6 +5,16 @@ exports.handleStop = handleStop;
 const service_lifecycle_service_1 = require("./app/service-lifecycle-service");
 const config_1 = require("./config");
 const text_1 = require("./text");
+function describeServiceManager(manager) {
+    switch (manager) {
+        case "launchd":
+            return (0, text_1.bi)("launchd（开机自启 + 异常自动拉起）", "launchd (auto-start on boot + auto-restart on failure)");
+        case "systemd-user":
+            return (0, text_1.bi)("systemd --user（开机自启 + 异常自动拉起）", "systemd --user (auto-start on boot + auto-restart on failure)");
+        default:
+            return (0, text_1.bi)("detached 进程（仅本次后台运行，不保证自动拉起）", "detached process (background only, no guaranteed auto-restart)");
+    }
+}
 /**
  * 后台启动 cslot 服务并写入 PID 文件。
  *
@@ -17,6 +27,7 @@ async function handleStart(portOverride) {
     const result = await (0, service_lifecycle_service_1.startManagedService)(portOverride);
     if (result.alreadyRunning) {
         console.log((0, text_1.bi)(`服务已在运行，PID=${result.pid}`, `Service is already running. PID=${result.pid}`));
+        console.log(`托管 / Manager: ${describeServiceManager(result.manager)}`);
         if (portOverride) {
             console.log((0, text_1.bi)(`已将新端口写入配置: ${result.port}`, `The new port has been saved to config: ${result.port}`));
             console.log((0, text_1.bi)("请先执行 cslot stop，再执行 cslot start 使新端口生效。", "Run cslot stop first, then cslot start to apply the new port."));
@@ -27,6 +38,7 @@ async function handleStart(portOverride) {
         console.log((0, text_1.bi)(`默认端口 4399 已被占用，已自动切换到 ${result.port}`, `Default port 4399 is busy. Automatically switched to ${result.port}`));
     }
     console.log((0, text_1.bi)(`服务已启动: http://${config.server.host}:${result.port}`, `Service started: http://${config.server.host}:${result.port}`));
+    console.log(`托管 / Manager: ${describeServiceManager(result.manager)}`);
     console.log(`PID: ${result.pid}`);
     console.log((0, text_1.bi)(`日志: ${result.logPath}`, `Log: ${result.logPath}`));
 }

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