codex-slot 0.1.24 → 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"));
@@ -13,13 +16,14 @@ const node_child_process_1 = require("node:child_process");
 const undici_1 = require("undici");
 const account_service_1 = require("./account-service");
 const account_store_1 = require("../account-store");
+const state_1 = require("../state");
 const codex_config_1 = require("../codex-config");
 const codex_auth_1 = require("../codex-auth");
 const cli_helpers_1 = require("../cli-helpers");
 const config_1 = require("../config");
-const scheduler_1 = require("../scheduler");
 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)();
@@ -173,19 +544,28 @@ function rollbackFailedStart(pid, previousConfig) {
  * 选择一个可用于接管主 `~/.codex` 登录态的账号。
  *
  * 业务规则：
- * 1. 优先复用当前调度器已经选中的最佳账号，保证 CLI 与代理请求走同一身份。
- * 2. 若当前没有可调度账号，则回退到首个启用且本地工作空间仍存在的账号。
- * 3. 若仍无可用账号，则返回 `null`，此时仅接管 provider 配置，不强行覆盖主登录态。
+ * 1. 优先使用状态面板中手动选择的 Codex App 登录态账号。
+ * 2. 手动选择存在但账号缺失或登录态不完整时直接报错，避免静默切到其他账号。
+ * 3. 未手动选择时，回退到首个启用且本地工作空间仍存在的账号。
+ * 4. 若仍无可用账号，则返回 `null`，此时仅接管 provider 配置，不强行覆盖主登录态。
  *
  * @returns 选中的受管账号；若不存在可接管账号则返回 `null`。
- * @throws 无显式抛出。
+ * @throws 当手动选择的账号不存在或登录态不完整时抛出错误。
  */
 function resolveManagedAuthAccount() {
-    const selected = (0, scheduler_1.pickBestAccount)()?.account;
-    if (selected && (0, account_store_1.hasCompleteCodexAuthState)(selected.codex_home)) {
+    const accounts = (0, account_service_1.listAccounts)();
+    const selectedAuthAccountId = (0, state_1.getSelectedCodexAuthAccountId)();
+    if (selectedAuthAccountId) {
+        const selected = accounts.find((account) => account.id === selectedAuthAccountId);
+        if (!selected) {
+            throw new Error(`手动选择的 Codex App 登录态账号不存在: ${selectedAuthAccountId}`);
+        }
+        if (!node_fs_1.default.existsSync(selected.codex_home) || !(0, account_store_1.hasCompleteCodexAuthState)(selected.codex_home)) {
+            throw new Error(`手动选择的 Codex App 登录态账号缺少完整 auth.json: ${selectedAuthAccountId}`);
+        }
         return selected;
     }
-    return ((0, account_service_1.listAccounts)().find((account) => account.enabled &&
+    return (accounts.find((account) => account.enabled &&
         node_fs_1.default.existsSync(account.codex_home) &&
         (0, account_store_1.hasCompleteCodexAuthState)(account.codex_home)) ?? null);
 }
@@ -246,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 {
@@ -253,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) {
@@ -263,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);
     }
@@ -290,7 +691,8 @@ async function startManagedService(portOverride) {
         pid: childPid,
         port,
         logPath,
-        autoSwitched
+        autoSwitched,
+        manager
     };
 }
 /**
@@ -300,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/app/status-service.js

@@ -6,6 +6,7 @@ exports.persistAccountEnabledState = persistAccountEnabledState;
 const config_1 = require("../config");
 const scheduler_1 = require("../scheduler");
 const status_1 = require("../status");
+const state_1 = require("../state");
 const usage_sync_1 = require("../usage-sync");
 /**
  * 刷新全部账号额度并返回最新状态快照。
@@ -29,6 +30,7 @@ function getStatusSnapshot() {
     return {
         statuses,
         selectedName: selected?.account.name ?? null,
+        codexAuthAccountId: (0, state_1.getSelectedCodexAuthAccountId)(),
         summary: (0, status_1.summarizeAccountStatuses)(statuses)
     };
 }

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/dist/state.js

@@ -15,6 +15,8 @@ exports.getUsageCache = getUsageCache;
 exports.setUsageRefreshError = setUsageRefreshError;
 exports.clearUsageRefreshError = clearUsageRefreshError;
 exports.getUsageRefreshError = getUsageRefreshError;
+exports.getSelectedCodexAuthAccountId = getSelectedCodexAuthAccountId;
+exports.setSelectedCodexAuthAccountId = setSelectedCodexAuthAccountId;
 exports.getManagedCodexConfigState = getManagedCodexConfigState;
 exports.getManagedCodexAuthState = getManagedCodexAuthState;
 exports.setManagedCodexConfigState = setManagedCodexConfigState;
@@ -24,7 +26,7 @@ exports.clearManagedCodexAuthState = clearManagedCodexAuthState;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const config_1 = require("./config");
-const STATE_SCHEMA_VERSION = 1;
+const STATE_SCHEMA_VERSION = 2;
 function getStatePath() {
     return node_path_1.default.join((0, config_1.getCslotHome)(), "state.json");
 }
@@ -41,6 +43,7 @@ function getStatePath() {
 function createDefaultState() {
     return {
         state_version: STATE_SCHEMA_VERSION,
+        selected_codex_auth_account_id: null,
         account_blocks: {},
         usage_cache: {},
         usage_refresh_errors: {},
@@ -60,6 +63,7 @@ function normalizeState(parsed) {
     const defaults = createDefaultState();
     return {
         state_version: STATE_SCHEMA_VERSION,
+        selected_codex_auth_account_id: parsed?.selected_codex_auth_account_id ?? defaults.selected_codex_auth_account_id,
         account_blocks: parsed?.account_blocks ?? defaults.account_blocks,
         usage_cache: parsed?.usage_cache ?? defaults.usage_cache,
         usage_refresh_errors: parsed?.usage_refresh_errors ?? defaults.usage_refresh_errors,
@@ -231,6 +235,32 @@ function getUsageRefreshError(accountId) {
     const state = loadState();
     return state.usage_refresh_errors[accountId] ?? null;
 }
+/**
+ * 读取用户在状态面板中手动选择的 Codex App 主登录态账号。
+ *
+ * 业务含义：
+ * 1. 该选择只决定 `cslot start` 复制哪个受管账号到主 `~/.codex/auth.json`。
+ * 2. 它不参与代理请求调度，也不改变账号 enabled 状态。
+ *
+ * @returns 手动选择的账号 id；未选择时返回 `null`。
+ * @throws 当 state 文件读取或解析失败时透传底层异常。
+ */
+function getSelectedCodexAuthAccountId() {
+    const state = loadState();
+    return state.selected_codex_auth_account_id ?? null;
+}
+/**
+ * 保存用户在状态面板中手动选择的 Codex App 主登录态账号。
+ *
+ * @param accountId 账号 id；传入 `null` 表示清除手动选择并恢复默认回退规则。
+ * @returns 无返回值。
+ * @throws 当 state 文件写入失败时透传底层异常。
+ */
+function setSelectedCodexAuthAccountId(accountId) {
+    updateState((state) => {
+        state.selected_codex_auth_account_id = accountId;
+    });
+}
 /**
  * 读取当前记录的 Codex `config.toml` 接管快照。
  *

package/dist/status-command.js

@@ -5,9 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleStatus = handleStatus;
 const node_readline_1 = __importDefault(require("node:readline"));
+const account_store_1 = require("./account-store");
 const account_service_1 = require("./app/account-service");
 const status_service_1 = require("./app/status-service");
 const scheduler_1 = require("./scheduler");
+const state_1 = require("./state");
+const codex_auth_1 = require("./codex-auth");
 const status_1 = require("./status");
 const text_1 = require("./text");
 const ANSI = {
@@ -206,16 +209,24 @@ function renderInteractiveScreen(lines) {
  * 计算交互式状态面板的初始光标位置。
  *
  * 业务规则：
- * 1. 优先定位到当前自动调度选中的账号。
- * 2. 若没有自动选中账号，则回退到首个可用账号。
- * 3. 若所有账号都不可用，则回退到首个已启用账号。
+ * 1. 优先定位到用户手动选择的 Codex App 登录态账号。
+ * 2. 若没有手动选择，则回退到当前自动调度选中的账号。
+ * 3. 若没有自动选中账号，则回退到首个可用账号。
+ * 4. 若所有账号都不可用，则回退到首个已启用账号。
  *
  * @param accounts 已按展示顺序排好的账号列表。
  * @param statuses 当前账号运行时状态快照。
+ * @param selectedAuthAccountId 用户手动选择的 Codex App 登录态账号 id。
  * @returns 初始光标所在的数组下标。
  * @throws 无显式抛出。
  */
-function resolveInitialCursorIndex(accounts, statuses) {
+function resolveInitialCursorIndex(accounts, statuses, selectedAuthAccountId) {
+    if (selectedAuthAccountId) {
+        const selectedAuthIndex = accounts.findIndex((account) => account.id === selectedAuthAccountId);
+        if (selectedAuthIndex >= 0) {
+            return selectedAuthIndex;
+        }
+    }
     const selected = (0, scheduler_1.pickBestAccount)();
     if (selected) {
         const selectedIndex = accounts.findIndex((account) => account.id === selected.account.id);
@@ -234,6 +245,31 @@ function resolveInitialCursorIndex(accounts, statuses) {
     }
     return 0;
 }
+/**
+ * 将状态面板中选中的账号立即应用为 Codex App 主登录态。
+ *
+ * 业务含义：
+ * 1. 该操作只切换主 `~/.codex/auth.json` 的来源账号，不改变代理调度顺序。
+ * 2. 被选择账号可以是 disabled，因为 enabled 只控制代理请求调度。
+ * 3. 登录态不完整时拒绝保存选择，避免下一次 `start` 静默失败或切错账号。
+ *
+ * @param account 用户在状态面板中选中的受管账号。
+ * @returns 失败时返回错误文本；成功时返回 `null`。
+ * @throws 无显式抛出；文件系统错误会转为返回文本。
+ */
+function applyCodexAuthSelection(account) {
+    try {
+        if (!(0, account_store_1.hasCompleteCodexAuthState)(account.codex_home)) {
+            return `账号 ${account.id} 缺少完整 auth.json`;
+        }
+        (0, state_1.setSelectedCodexAuthAccountId)(account.id);
+        (0, codex_auth_1.applyManagedCodexAuth)(account.codex_home, { sourceAccountId: account.id });
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
 /**
  * 进入账号启用状态的交互式切换界面，并在用户确认退出后恢复终端状态。
  *
@@ -256,7 +292,8 @@ async function handleInteractiveToggle(initialStatuses) {
         return;
     }
     const accounts = [...accountsFromConfig].sort((left, right) => left.name.localeCompare(right.name));
-    let cursor = resolveInitialCursorIndex(accounts, initialStatuses ?? (0, status_1.collectAccountStatuses)());
+    let selectedAuthAccountId = (0, state_1.getSelectedCodexAuthAccountId)();
+    let cursor = resolveInitialCursorIndex(accounts, initialStatuses ?? (0, status_1.collectAccountStatuses)(), selectedAuthAccountId);
     let changed = false;
     enterInteractiveScreen();
     return await new Promise((resolve) => {
@@ -277,9 +314,10 @@ async function handleInteractiveToggle(initialStatuses) {
                 if (!status) {
                     return null;
                 }
+                const markers = `${account.id === autoSelectedId ? "*" : ""}${account.id === selectedAuthAccountId ? "@" : ""}`;
                 return {
                     ...status,
-                    name: account.id === autoSelectedId ? `${status.name}*` : status.name
+                    name: markers ? `${status.name}${markers}` : status.name
                 };
             })
                 .filter((item) => item !== null);
@@ -305,11 +343,12 @@ async function handleInteractiveToggle(initialStatuses) {
                 "",
                 renderSectionHeader("summary", rightWidth, styled),
                 renderSummaryLine(summary, rightWidth < 42, styled),
-                `selected=${latestSnapshot.selectedName ?? "none"}`,
+                `scheduler=${latestSnapshot.selectedName ?? "none"}`,
+                `codex_auth=${selectedAuthAccountId ?? "none"}`,
                 ...(refreshStatusText ? [`refresh=${refreshStatusText}`] : []),
                 "",
                 renderSectionHeader("help", rightWidth, styled),
-                "↑/↓ move    Space toggle    r refresh    Enter/q exit"
+                "↑/↓ move    Space toggle    a app-auth    c clear    r refresh    Enter/q exit"
             ];
             if (wideLayout) {
                 renderInteractiveScreen(renderColumns(accountLines, sideLines, 3));
@@ -367,6 +406,30 @@ async function handleInteractiveToggle(initialStatuses) {
                 render();
                 return;
             }
+            if (key.name === "a") {
+                const account = accounts[cursor];
+                if (!account) {
+                    return;
+                }
+                const errorMessage = applyCodexAuthSelection(account);
+                if (errorMessage) {
+                    refreshStatusText = errorMessage;
+                    render();
+                    return;
+                }
+                selectedAuthAccountId = account.id;
+                refreshStatusText = `codex_auth=${account.id}`;
+                render();
+                return;
+            }
+            if (key.name === "c") {
+                selectedAuthAccountId = null;
+                (0, state_1.setSelectedCodexAuthAccountId)(null);
+                (0, codex_auth_1.deactivateManagedCodexAuth)();
+                refreshStatusText = "codex_auth=cleared";
+                render();
+                return;
+            }
             if (key.name === "r") {
                 if (refreshing) {
                     return;
@@ -419,10 +482,11 @@ async function handleStatus(options) {
     }
     const displayStatuses = snapshot.statuses.map((item) => ({
         ...item,
-        name: item.id === (0, scheduler_1.pickBestAccount)()?.account.id ? `${item.name}*` : item.name
+        name: `${item.name}${item.id === (0, scheduler_1.pickBestAccount)()?.account.id ? "*" : ""}${item.id === snapshot.codexAuthAccountId ? "@" : ""}`
     }));
     console.log((0, status_1.renderStatusTable)(displayStatuses));
     console.log("");
     console.log(`available=${snapshot.summary.available} 5h_limited=${snapshot.summary.fiveHourLimited} weekly_limited=${snapshot.summary.weeklyLimited}`);
-    console.log(`selected=${snapshot.selectedName ?? "none"}`);
+    console.log(`scheduler=${snapshot.selectedName ?? "none"}`);
+    console.log(`codex_auth=${snapshot.codexAuthAccountId ?? "none"}`);
 }

package/dist/status.js

@@ -201,7 +201,7 @@ function styleStatusCell(status, item, styled) {
     return status;
 }
 /**
- * 对当前自动选中账号的名称做轻量强调。
+ * 对当前自动调度账号或 Codex App 登录态账号的名称做轻量强调。
  *
  * @param name 账号展示名称。
  * @param styled 是否启用 ANSI 样式。
@@ -209,7 +209,7 @@ function styleStatusCell(status, item, styled) {
  * @throws 无显式抛出。
  */
 function styleNameCell(name, styled) {
-    if (!styled || !name.endsWith("*")) {
+    if (!styled || (!name.includes("*") && !name.includes("@"))) {
         return name;
     }
     return styleCell(name, TABLE_ANSI.cyan, styled);

package/package.json

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