codex-slot 0.1.25 → 0.1.26

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/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

@@ -26,6 +26,35 @@ async function readRawRequestBody(stream) {
     }
     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)));
+        }
+    }
+}
 /**
  * 启动一个极轻量本地服务，供后续接入代理或脚本化查询使用。
  *
@@ -68,12 +97,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 +115,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 解析与大小限制拦截。

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/package.json

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