cursor-feedback 2.3.0 → 2.4.0

package/dist/mcp-server.js

@@ -59,6 +59,9 @@ const os = __importStar(require("os"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const feishu_js_1 = require("./feishu.js");
+const cli_launcher_js_1 = require("./cli-launcher.js");
+const keep_awake_js_1 = require("./keep-awake.js");
+const daemon_install_js_1 = require("./daemon-install.js");
 // ⚠️ MCP stdio 协议要求 stdout 只承载 JSON-RPC 消息。第三方库（尤其飞书 SDK 的内置 logger，
 // 输出形如 "[info]: [...]"）会用 console.log/info/debug 往 stdout 打日志，一旦混入就会让
 // Cursor 端 JSON 解析失败、连接进入 failed（表现为 "Not connected"）。这里在进程最早期把这三个
@@ -86,7 +89,7 @@ const PKG_VERSION = (() => {
  * MCP Feedback Server
  */
 class McpFeedbackServer {
-    constructor(port = 8766) {
+    constructor(port = 8766, daemonMode = false) {
         this.httpServer = null;
         // 待处理的反馈请求
         this.pendingRequests = new Map();
@@ -95,6 +98,8 @@ class McpFeedbackServer {
         // 飞书桥接（可选；未配置时不加载 SDK、零开销）
         this.feishu = new feishu_js_1.FeishuBridge();
         this.feishuRoutingSetup = false;
+        // 飞书 /new 命令拉起的 headless CLI 会话（同一实例同时最多一个）
+        this.cliLauncher = new cli_launcher_js_1.CliLauncher();
         /**
          * 抢跑暂存：用户在「上一轮反馈刚结束、下一轮卡片还没注册」的空窗里直接发来的「无主」消息。
          * 暂存后等下一轮 pending 一注册立即兑现，避免回复石沉大海（修复用户反馈的竞态 bug）。
@@ -148,8 +153,16 @@ class McpFeedbackServer {
         // stop() 防重入：server.close() 会触发 transport.onclose → 回调里又调 stop()，
         // 无标志位会无限递归直至 "Maximum call stack size exceeded"（日志曾刷出数万条 Stopping server...）
         this.stopping = false;
+        // 防睡眠（守护模式启用；仅接电源时阻止系统睡眠）
+        this.keepAwake = new keep_awake_js_1.KeepAwake();
+        /**
+         * 已结束请求的结果缓存（wire id → 当时的结果）：供「迟到的重复投递」精确重放。
+         * 容量与时效都收紧（feedback 结果可能含 base64 图片，不能无限囤积）。
+         */
+        this.settledByWire = new Map();
         this.port = port;
         this.basePort = port;
+        this.daemonMode = daemonMode;
         this.server = new index_js_1.Server({
             name: 'cursor-feedback-server',
             version: PKG_VERSION,
@@ -224,14 +237,17 @@ class McpFeedbackServer {
             };
         });
         // 处理工具调用
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request, extra) => {
             // AI 发起调用，刷新活动时间，避免被 watchdog 误判为闲置
             this.lastActivityTime = Date.now();
             const { name, arguments: args } = request.params;
+            // JSON-RPC 请求 id（同一连接内唯一）：客户端把同一次 tool call 重复投递时若复用
+            // 同一 id，可据此做精确去重 / 结果重放（比 summary 内容启发式可靠）。
+            const wireKey = extra?.requestId !== undefined ? String(extra.requestId) : undefined;
             try {
                 switch (name) {
                     case 'interactive_feedback':
-                        return await this.handleInteractiveFeedback(args);
+                        return await this.handleInteractiveFeedback(args, wireKey);
                     case 'get_system_info':
                         return this.handleGetSystemInfo();
                     default:
@@ -252,8 +268,9 @@ class McpFeedbackServer {
     }
     /**
      * 处理交互式反馈请求
+     * @param wireKey 本次调用的 JSON-RPC 请求 id（用于重复投递的精确识别与结果重放）
      */
-    async handleInteractiveFeedback(args) {
+    async handleInteractiveFeedback(args, wireKey) {
         // 参数校验：project_directory 是必填项
         if (!args?.project_directory) {
             const receivedParams = JSON.stringify(args || {});
@@ -276,15 +293,29 @@ class McpFeedbackServer {
         const envTimeout = process.env.MCP_FEEDBACK_TIMEOUT ? parseInt(process.env.MCP_FEEDBACK_TIMEOUT, 10) : null;
         const timeout = envTimeout || args?.timeout || 300;
         const requestId = this.generateRequestId();
-        // 重复投递识别：同窗口 + 同 summary + 旧请求还很新 → 视为客户端/传输层对同一次调用的
-        // 重复投递（非新一轮），直接 join 旧等待共享结果：不发新卡、不顶旧请求（顶了会让
-        // 先到的那次调用收到 SUPERSEDED、AI 误以为被新会话取代而提前收尾）。
-        const dup = this.findDuplicatePending(projectDir, summary);
+        // 重复投递识别：客户端/传输层会把同一次 tool call 原样重复投递（实测某一时刻把进程内
+        // 所有 in-flight 调用各重投一遍，距原投递可晚至 3~8 分钟，无固定上限）。重复投递必须
+        // join 原等待共享结果，绝不能当新一轮：不发新卡、不顶旧请求——顶了会让原调用收到
+        // SUPERSEDED（AI 误以为被新会话取代而提前收尾），且重投开出的幽灵卡片没人认领，
+        // 用户回复它只会石沉大海。
+        const dup = this.findDuplicatePending(projectDir, summary, timeout, wireKey);
         if (dup) {
-            debugLog(`Duplicate delivery detected for request ${dup.id}; joining its wait instead of superseding`);
+            debugLog(`Duplicate delivery detected (matched by ${dup.via}) for request ${dup.id}; joining its wait instead of superseding`);
             const outcome = await new Promise((res) => dup.waiters.push(res));
+            this.rememberSettledWire(wireKey, outcome, dup.id);
             return this.outcomeToResult(outcome, dup.id);
         }
+        // 迟到的重复投递（原请求已结束）：同 wire id 精确命中已结束请求 → 原样重放当时的结果。
+        // 绝不能开新一轮：原调用早已返回、没人会认领新卡，用户回复只会丢失。
+        // 只按 wire id 匹配、绝不按 summary——AI 超时续期的新一轮常复用同一句 summary，
+        // 按内容重放旧超时会造成「新调用秒收超时 → 立即重调 → 又秒收」的快速空转。
+        if (wireKey) {
+            const settled = this.settledByWire.get(wireKey);
+            if (settled) {
+                debugLog(`Late duplicate delivery (wire id ${wireKey}) for settled request ${settled.requestId}; replaying its outcome`);
+                return this.outcomeToResult(settled.outcome, settled.requestId);
+            }
+        }
         // 作废上一轮残留的「僵尸」请求：单实例单窗口同时只应有一个活跃反馈请求。
         // 旧请求多半是对话被压缩 / 客户端取消后还卡在 await 的残留（要等 timeout 才自然结束），
         // 不清理会让 pendingCount 虚高、全局视角误判「多个窗口在等」
@@ -324,7 +355,8 @@ class McpFeedbackServer {
         }
         try {
             // 等待用户反馈
-            const outcome = await this.waitForFeedback(request, timeout * 1000);
+            const outcome = await this.waitForFeedback(request, timeout * 1000, wireKey);
+            this.rememberSettledWire(wireKey, outcome, requestId);
             return this.outcomeToResult(outcome, requestId);
         }
         catch (error) {
@@ -363,6 +395,9 @@ class McpFeedbackServer {
             // 文本、图片、文件任一非空都算有效反馈（此前只认文本，导致纯图片/文件被丢弃）
             if (!text && images.length === 0 && files.length === 0)
                 return;
+            // 斜杠命令优先于反馈路由：用户显式输入命令时不应被当成对某张卡片的回复或排队消息。
+            if (/^\/(new|stop|model|cwd)\b/.test(text) && this.handleCliCommand(text, chatId))
+                return;
             if (parentId) {
                 // 用户「回复」了某条卡片 → 用 parent_id 精确路由
                 const reqId = this.feishu.resolveParent(parentId);
@@ -438,6 +473,132 @@ class McpFeedbackServer {
             }
         });
     }
+    /** 展开命令里的目录写法（支持 ~ 前缀和 Windows 盘符路径），非法/不存在返回 null */
+    expandDirToken(token) {
+        if (!token)
+            return null;
+        const looksLikePath = token.startsWith('/') || token.startsWith('~') || /^[a-zA-Z]:[\\/]/.test(token);
+        if (!looksLikePath)
+            return null;
+        const expanded = token.startsWith('~')
+            ? path.join(os.homedir(), token.slice(1))
+            : token;
+        try {
+            if (fs.statSync(expanded).isDirectory())
+                return expanded;
+        }
+        catch {
+            // 不存在
+        }
+        return null;
+    }
+    /**
+     * 处理飞书斜杠命令。返回是否已消费该消息。
+     * - /new [工作目录] 任务描述：拉起一个 headless CLI 会话（非交互 + maxMode=false，扣 1 次请求）
+     * - /stop：终止运行中的 CLI 会话
+     * - /model [模型id]：查看 / 设置 CLI 会话模型（持久化；无论选什么模型都强制 maxMode=false）
+     * - /cwd [目录]：查看 / 设置默认工作目录（持久化；IDE 不开时 /new 用它）
+     */
+    handleCliCommand(text, chatId) {
+        if (/^\/stop\b/.test(text)) {
+            if (this.cliLauncher.stop()) {
+                this.feishu.replyText(chatId, '🛑 正在终止 CLI 会话…结束后我会再发一条收尾消息。');
+            }
+            else {
+                this.feishu.replyText(chatId, '当前没有运行中的 CLI 会话。');
+            }
+            return true;
+        }
+        const mModel = text.match(/^\/model(?:\s+(\S+))?\s*$/);
+        if (mModel) {
+            if (mModel[1]) {
+                this.cliLauncher.writeSettings({ model: mModel[1] });
+                this.feishu.replyText(chatId, `✅ CLI 模型已设为 ${mModel[1]}\n（无论什么模型，拉起前都会强制 maxMode=false，不会走 Max 计费）`);
+            }
+            else {
+                this.feishu.replyText(chatId, `当前 CLI 模型：${this.cliLauncher.model()}\n设置：/model 模型id（例如 /model claude-fable-5-thinking-max）`);
+            }
+            return true;
+        }
+        const mCwd = text.match(/^\/cwd(?:\s+(\S+))?\s*$/);
+        if (mCwd) {
+            if (mCwd[1]) {
+                const dir = this.expandDirToken(mCwd[1]);
+                if (!dir) {
+                    this.feishu.replyText(chatId, `❌ 目录不存在或不是有效路径：${mCwd[1]}`);
+                }
+                else {
+                    this.cliLauncher.writeSettings({ defaultCwd: dir });
+                    this.feishu.replyText(chatId, `✅ 默认工作目录已设为 ${dir}\n之后 /new 不带路径时都用它。`);
+                }
+            }
+            else {
+                const cur = this.cliLauncher.defaultCwd();
+                this.feishu.replyText(chatId, `当前默认工作目录：${cur || '（未设置，回退到活跃窗口工作区或主目录）'}\n设置：/cwd 绝对路径`);
+            }
+            return true;
+        }
+        const m = text.match(/^\/new\s*([\s\S]*)$/);
+        if (!m)
+            return false;
+        let task = (m[1] || '').trim();
+        if (!task) {
+            this.feishu.replyText(chatId, '用法：/new 任务描述\n' +
+                '可选在任务前带一个已存在的目录作为工作目录：\n' +
+                '/new /Users/me/proj 帮我看下测试为什么挂了\n' +
+                '相关命令：/cwd 设默认目录、/model 设模型、/stop 终止会话。');
+            return true;
+        }
+        if (this.cliLauncher.isRunning()) {
+            this.feishu.replyText(chatId, '已有一个 CLI 会话在运行：' + this.cliLauncher.describe() + '\n发 /stop 可先终止它。');
+            return true;
+        }
+        // 工作目录优先级：命令里显式路径 > /cwd 持久化默认目录 > 本实例归属窗口 > 主目录。
+        // 注意 ownerWorkspace 是小写归一化路径，macOS 默认大小写不敏感文件系统下可直接使用。
+        let cwd = this.cliLauncher.defaultCwd() ||
+            (this.ownerWorkspace && fs.existsSync(this.ownerWorkspace)
+                ? this.ownerWorkspace
+                : os.homedir());
+        const explicitDir = this.expandDirToken(task.split(/\s+/)[0]);
+        if (explicitDir) {
+            cwd = explicitDir;
+            task = task.slice(task.split(/\s+/)[0].length).trim();
+        }
+        if (!task) {
+            this.feishu.replyText(chatId, '只给了目录没给任务。用法：/new [工作目录] 任务描述');
+            return true;
+        }
+        const err = this.cliLauncher.start(task, cwd, (result) => this.onCliSessionDone(result, chatId));
+        if (err) {
+            this.feishu.replyText(chatId, '❌ 拉起 CLI 会话失败：' + err);
+        }
+        else {
+            this.feishu.replyText(chatId, '🚀 CLI 会话已拉起（非交互模式，已强制 maxMode=false，按 1 次请求计费）\n' +
+                `模型：${this.cliLauncher.model()}\n` +
+                `工作目录：${cwd}\n` +
+                `任务：${task.length > 100 ? task.slice(0, 100) + '…' : task}\n\n` +
+                'AI 需要和你沟通时会发反馈卡片，直接回复卡片即可；发 /stop 可随时终止。');
+        }
+        return true;
+    }
+    /** CLI 会话结束的收尾回执：把 agent 的最终输出（尾部）发回飞书 */
+    onCliSessionDone(result, chatId) {
+        const mins = Math.max(1, Math.round(result.elapsedMs / 60000));
+        let head;
+        if (result.stopped)
+            head = '🛑 CLI 会话已按你的要求终止';
+        else if (result.timedOut)
+            head = '⏱ CLI 会话超过时长上限，已被终止';
+        else if (result.code === 0)
+            head = '✅ CLI 会话已完成';
+        else
+            head = `⚠️ CLI 会话异常退出（code=${result.code}）`;
+        let body = result.output || result.errorOutput || '（无输出）';
+        // 飞书单条消息别太长：保留尾部（结论一般在最后）
+        if (body.length > 1800)
+            body = '…' + body.slice(body.length - 1800);
+        this.feishu.replyText(chatId, `${head}（用时约 ${mins} 分钟）\n\n${body}`);
+    }
     /** 当前生效的超时续期开关（优先 UI 开关 autoRetryOverride，未设置时回退环境变量/默认开启） */
     effectiveAutoRetry() {
         return this.autoRetryOverride !== null
@@ -606,19 +767,49 @@ class McpFeedbackServer {
             this.pendingRequests.delete(reqId);
         }
     }
-    findDuplicatePending(projectDir, summary) {
+    /**
+     * 查找可 join 的「重复投递」等待，两级匹配：
+     * 1) wire id 精确匹配：同一条 JSON-RPC 请求（同 id）还在等待 → 必是重复投递；
+     * 2) 内容启发式：同窗口 + 同 summary + 同 timeout，且原请求仍在 pending（覆盖客户端
+     *    重投时换了新 wire id 的情况）。
+     * 内容启发式不设时间窗——旧实现的 90s 窗口被实测击穿（重投可晚至 3~8 分钟，无固定上限）。
+     * 不设窗口是安全的：pending 仍存活 = 原调用尚未返回 = 同一会话不可能已合法开启新一轮；
+     * 不同会话在同一窗口撞出一字不差的 summary + timeout 概率可忽略，即便撞上，
+     * join（双方共享同一份回复）也远比 supersede（悄悄掐掉别人的等待）安全。
+     */
+    findDuplicatePending(projectDir, summary, timeout, wireKey) {
         const owner = this.normalizePath(projectDir);
         for (const [id, pending] of this.pendingRequests) {
+            if (wireKey !== undefined && pending.wireId === wireKey) {
+                return { id, via: 'wire id', waiters: pending.waiters };
+            }
             if (this.normalizePath(pending.projectDir) !== owner)
                 continue;
             if (pending.request.summary !== summary)
                 continue;
-            if (Date.now() - pending.request.timestamp > McpFeedbackServer.DUP_JOIN_MS)
+            if (pending.request.timeout !== timeout)
                 continue;
-            return { id, waiters: pending.waiters };
+            return { id, via: 'content', waiters: pending.waiters };
         }
         return null;
     }
+    rememberSettledWire(wireKey, outcome, requestId) {
+        if (!wireKey)
+            return;
+        const now = Date.now();
+        this.settledByWire.set(wireKey, { outcome, requestId, at: now });
+        for (const [k, v] of this.settledByWire) {
+            if (now - v.at > McpFeedbackServer.SETTLED_WIRE_TTL_MS)
+                this.settledByWire.delete(k);
+        }
+        // Map 按插入序迭代，超限时先淘汰最早的
+        while (this.settledByWire.size > McpFeedbackServer.SETTLED_WIRE_MAX) {
+            const oldest = this.settledByWire.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.settledByWire.delete(oldest);
+        }
+    }
     /**
      * 把等待结果翻译成 MCP 工具响应（主等待与重复投递 join 的等待共用同一段收尾语义）。
      */
@@ -700,7 +891,7 @@ class McpFeedbackServer {
      * 等待用户反馈：注册 pending 并挂起，结果通过 waiters 广播——
      * 首个调用与后续 join 进来的重复投递调用都会收到同一份结果。
      */
-    waitForFeedback(request, timeoutMs) {
+    waitForFeedback(request, timeoutMs, wireKey) {
         return new Promise((resolve) => {
             const requestId = request.id;
             const projectDir = request.projectDir;
@@ -738,6 +929,7 @@ class McpFeedbackServer {
                 remainingMs: timeoutMs,
                 request,
                 waiters,
+                wireId: wireKey,
             });
             // 抢跑兑现：空窗期的面板提交（优先，用户显式点了发送）与飞书暂存消息，
             // 本轮 pending 一注册立即作为回复提交；最后是忙时队列里排队的追加消息
@@ -1567,6 +1759,30 @@ class McpFeedbackServer {
                         res.end(JSON.stringify({ success: true, status: this.feishu.getStatus() }));
                         return;
                     }
+                    // 常驻守护：状态查询 / 安装 / 卸载（供插件面板「常驻服务」开关调用）
+                    if (req.method === 'GET' && req.url === '/api/daemon/status') {
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ...(0, daemon_install_js_1.daemonStatus)(), currentVersion: PKG_VERSION }));
+                        return;
+                    }
+                    if (req.method === 'POST' && (req.url === '/api/daemon/install' || req.url === '/api/daemon/uninstall')) {
+                        const isInstall = req.url === '/api/daemon/install';
+                        try {
+                            if (isInstall && !(0, daemon_install_js_1.daemonSupported)()) {
+                                res.writeHead(400, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ error: `平台 ${process.platform} 暂不支持常驻守护` }));
+                                return;
+                            }
+                            const status = isInstall ? (0, daemon_install_js_1.installDaemon)() : (0, daemon_install_js_1.uninstallDaemon)();
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ success: true, ...status, currentVersion: PKG_VERSION }));
+                        }
+                        catch (e) {
+                            res.writeHead(500, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: String(e) }));
+                        }
+                        return;
+                    }
                     // 跨实例转发的飞书回复（由其他窗口的 server 广播过来）
                     if (req.method === 'POST' && req.url === '/api/feishu/inbound') {
                         let body = '';
@@ -1800,6 +2016,16 @@ class McpFeedbackServer {
             if (settings && typeof settings.autoRetry === 'boolean') {
                 this.autoRetryOverride = settings.autoRetry;
             }
+            if (this.daemonMode) {
+                // 守护模式：没有 stdio 客户端（launchd/计划任务拉起，stdin 是 /dev/null），
+                // 不连 MCP 传输、不装 stdin 退出钩子、不开看门狗（父进程本来就是 launchd）。
+                // 顺带启动防睡眠：锁屏后手机随时能唤起（仅接电源时生效，不偷耗电池）。
+                if (process.env.CURSOR_FEEDBACK_KEEP_AWAKE !== 'false') {
+                    this.keepAwake.start();
+                }
+                debugLog(`Daemon mode started (v${PKG_VERSION}), Feishu bridge + /new launcher only`);
+                return;
+            }
             // 启动 MCP stdio 传输
             const transport = new stdio_js_1.StdioServerTransport();
             await this.server.connect(transport);
@@ -1885,6 +2111,8 @@ class McpFeedbackServer {
         }
         this.stopping = true;
         debugLog('Stopping server...');
+        // 停止防睡眠（子进程退出，电源断言自动释放）
+        this.keepAwake.stop();
         // 关闭看门狗定时器
         if (this.watchdogTimer) {
             clearInterval(this.watchdogTimer);
@@ -1930,16 +2158,30 @@ McpFeedbackServer.QUEUE_MAX = 100;
  *（只剩别的窗口在扫端口）→ 视为我的窗口已关、本实例是僵尸：不再上报 pending，避免污染全局计数。
  */
 McpFeedbackServer.OWNER_IDLE_MS = 12000;
-/**
- * 查找可 join 的「重复投递」等待：同窗口 + 同 summary + 注册时间在 DUP_JOIN_MS 内。
- * AI 每一轮的 summary 几乎不可能与上一轮一字不差，短窗口内完全相同基本可断定为
- * 客户端/传输层对同一次 tool call 的重复投递。
- */
-McpFeedbackServer.DUP_JOIN_MS = 90000;
+McpFeedbackServer.SETTLED_WIRE_TTL_MS = 10 * 60 * 1000;
+McpFeedbackServer.SETTLED_WIRE_MAX = 20;
 // 主函数
 async function main() {
+    // 子命令：常驻守护的安装 / 卸载 / 状态查询（供 npx cursor-feedback install-daemon 等直接使用）
+    const argv = process.argv.slice(2);
+    const sub = argv.find((a) => !a.startsWith('-'));
+    if (sub === 'install-daemon' || sub === 'uninstall-daemon' || sub === 'daemon-status') {
+        try {
+            const status = sub === 'install-daemon' ? (0, daemon_install_js_1.installDaemon)()
+                : sub === 'uninstall-daemon' ? (0, daemon_install_js_1.uninstallDaemon)()
+                    : (0, daemon_install_js_1.daemonStatus)();
+            // 子命令是给人看的，结果走 stdout（无 MCP 客户端，无 stdio 污染问题）
+            process.stdout.write(JSON.stringify(status, null, 2) + '\n');
+            process.exit(0);
+        }
+        catch (e) {
+            process.stderr.write(String(e) + '\n');
+            process.exit(1);
+        }
+    }
+    const daemonMode = argv.includes('--daemon');
     const port = 61927;
-    const server = new McpFeedbackServer(port);
+    const server = new McpFeedbackServer(port, daemonMode);
     // 处理进程信号
     process.on('SIGINT', () => {
         debugLog('Received SIGINT');
@@ -1951,24 +2193,28 @@ async function main() {
         server.stop();
         process.exit(0);
     });
-    // 监听 stdin 关闭（Cursor 关闭时会触发）
-    process.stdin.on('close', () => {
-        debugLog('stdin closed, exiting...');
-        server.stop();
-        // 给 100ms 缓冲后强制退出
-        setTimeout(() => process.exit(0), 100);
-    });
-    process.stdin.on('end', () => {
-        debugLog('stdin ended, exiting...');
-        server.stop();
-        setTimeout(() => process.exit(0), 100);
-    });
-    // stdin 出错（父进程经 npx 中间层异常断开时可能触发）同样退出，避免残留
-    process.stdin.on('error', (error) => {
-        debugLog(`stdin error, exiting: ${error}`);
-        server.stop();
-        setTimeout(() => process.exit(0), 100);
-    });
+    // stdin 退出钩子仅用于「被 MCP 客户端拉起」的场景。守护模式下 stdin 是 /dev/null，
+    // 启动瞬间就会触发 close/end，装上这些钩子进程会立刻自杀。
+    if (!daemonMode) {
+        // 监听 stdin 关闭（Cursor 关闭时会触发）
+        process.stdin.on('close', () => {
+            debugLog('stdin closed, exiting...');
+            server.stop();
+            // 给 100ms 缓冲后强制退出
+            setTimeout(() => process.exit(0), 100);
+        });
+        process.stdin.on('end', () => {
+            debugLog('stdin ended, exiting...');
+            server.stop();
+            setTimeout(() => process.exit(0), 100);
+        });
+        // stdin 出错（父进程经 npx 中间层异常断开时可能触发）同样退出，避免残留
+        process.stdin.on('error', (error) => {
+            debugLog(`stdin error, exiting: ${error}`);
+            server.stop();
+            setTimeout(() => process.exit(0), 100);
+        });
+    }
     // 捕获未处理的异常：记录日志后退出。
     // ⚠️ 绝不能“吞掉异常继续运行”——否则 stdin 在父进程断开后产生的反复错误会形成
     //    busy-loop，导致 CPU 占满且进程永不退出（本次修复的核心症状之一）。

package/dist/webview/index.html

@@ -210,7 +210,18 @@
         <p class="feishu-modal__desc">{{i18n.queueWhenBusyDesc}}</p>
       </div>
 
-      <!-- 区块③：飞书通知（推送开关 + 凭证 + 绑定状态） -->
+      <!-- 区块③：常驻服务（IDE 关闭时仍保持飞书链路 + /new 拉起 CLI；接电自动防睡眠） -->
+      <div class="feishu-section">
+        <label class="feishu-switch">
+          <span class="feishu-switch__label feishu-switch__label--strong">{{i18n.daemonLabel}}</span>
+          <input id="daemonToggle" type="checkbox" class="feishu-switch__input">
+          <span class="feishu-switch__track"><span class="feishu-switch__thumb"></span></span>
+        </label>
+        <p class="feishu-modal__desc">{{i18n.daemonDesc}}</p>
+        <p id="daemonStatusText" class="feishu-modal__desc feishu-modal__desc--sub"></p>
+      </div>
+
+      <!-- 区块④：飞书通知（推送开关 + 凭证 + 绑定状态） -->
       <div class="feishu-section">
         <label class="feishu-switch">
           <span class="feishu-switch__label feishu-switch__label--strong">{{i18n.feishuSettings}}</span>

package/dist/webview/script.js

@@ -206,6 +206,8 @@
     fillFeishuInputs();
     feishuModal.classList.remove('hidden');
     feishuModal.setAttribute('aria-hidden', 'false');
+    // 打开设置时向 server 查一次常驻服务状态（安装与否、版本）
+    requestDaemonStatus();
     setTimeout(() => feishuAppIdInput.focus(), 0);
   }
   function closeFeishuModal() {
@@ -228,6 +230,34 @@
     }
   });
 
+  // ---------- 常驻服务（IDE 关闭也可用）开关 ----------
+  const daemonToggle = document.getElementById('daemonToggle');
+  const daemonStatusText = document.getElementById('daemonStatusText');
+  function requestDaemonStatus() {
+    daemonToggle.disabled = true;
+    vscode.postMessage({ type: 'requestDaemonStatus' });
+  }
+  daemonToggle.addEventListener('change', () => {
+    // 安装/卸载是耗时操作（拷贝依赖 + 注册自启），期间锁住开关避免连点
+    daemonToggle.disabled = true;
+    daemonStatusText.textContent = i18n.daemonWorking || 'Working…';
+    vscode.postMessage({ type: 'toggleDaemon', payload: { enabled: daemonToggle.checked } });
+  });
+  function updateDaemonUI(s) {
+    if (!s) return;
+    daemonToggle.disabled = !s.supported;
+    daemonToggle.checked = !!s.installed;
+    let txt = '';
+    if (!s.supported) {
+      txt = i18n.daemonNotSupported || 'Not supported on this platform';
+    } else if (s.error) {
+      txt = (i18n.daemonFailed || 'Operation failed: {error}').replace('{error}', s.error);
+    } else if (s.installed) {
+      txt = (i18n.daemonInstalled || 'Installed v{version}').replace('{version}', s.installedVersion || '?');
+    }
+    daemonStatusText.textContent = txt;
+  }
+
   // ---------- 扫码一键创建飞书应用 ----------
   // 点「扫码快速创建」→ extension 向 server 发起 Device Grant 流程 → 面板展示二维码 →
   // 用户在飞书确认 → 凭证自动写入 server 磁盘并生效，这里刷新输入框回显
@@ -1613,6 +1643,10 @@
         updateFeishuUI(message.payload);
         break;
 
+      case 'daemonState':
+        updateDaemonUI(message.payload);
+        break;
+
       case 'feishuRegisterState':
         handleRegisterState(message.payload);
         break;

package/package.json

@@ -2,7 +2,7 @@
   "name": "cursor-feedback",
   "displayName": "Cursor Feedback",
   "description": "One Cursor conversation, unlimited AI interactions - Save your monthly request quota! Interactive feedback loop for AI chat via MCP",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "icon": "icon.png",
   "author": "jianger666",
   "license": "MIT",
@@ -147,7 +147,7 @@
     "watch": "tsc -watch -p ./",
     "lint": "eslint src --ext ts",
     "start:mcp": "node dist/mcp-server.js",
-    "test:smoke": "npm run compile && node scripts/smoke-queue.js",
+    "test:smoke": "npm run compile && node scripts/smoke-queue.js && node scripts/smoke-dup.js && node scripts/smoke-cli-launcher.js && node scripts/smoke-daemon.js",
     "prepublishOnly": "npm run check-changelog && npm run compile",
     "check-changelog": "node scripts/check-changelog.js",
     "release": "standard-version",