cursor-feedback 2.4.0 → 2.4.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [2.4.1](https://github.com/jianger666/cursor-feedback-extension/compare/v2.4.0...v2.4.1) (2026-07-06)
+
+
+### Bug Fixes
+
+* **cli:** CLI 会话全局锁——多窗口/守护多实例并存时 /new /stop 跨实例一致 ([679c3ef](https://github.com/jianger666/cursor-feedback-extension/commit/679c3ef3ce43af768be939d4059a452cd3d20178))
+
 ## [2.4.0](https://github.com/jianger666/cursor-feedback-extension/compare/v2.3.1...v2.4.0) (2026-07-06)
 
 

package/dist/cli-launcher.js

@@ -62,15 +62,113 @@ class CliLauncher {
         this.taskBrief = '';
         this.stopRequested = false;
     }
+    /* ---------- 磁盘全局会话锁 ----------
+     * 「同时只跑一个 CLI 会话」必须全局生效：多窗口 + 守护进程是多实例并存，
+     * 飞书把 /new、/stop 推给哪个实例是不确定的（长连接负载均衡）。只看本实例的
+     * child 会被击穿：A 拉了会话，下一条 /new 推给 B，B 以为空闲又拉一个。
+     * 锁文件记录会话进程 pid，任何实例都能据此判忙 / 跨实例终止；
+     * 持锁进程崩溃后锁自动失效（pid 探活），不会死锁。 */
+    lockPath() {
+        return path.join(os.homedir(), '.cursor-feedback', 'cli-session.lock');
+    }
+    readLock() {
+        try {
+            const j = JSON.parse(fs.readFileSync(this.lockPath(), 'utf-8'));
+            return typeof j.pid === 'number' ? j : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static pidAlive(pid) {
+        if (!pid || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * pid 是否确实是 cursor-agent 会话进程。防 pid 复用：锁残留（极端崩溃）后系统把同号
+     * pid 分给了无关进程，跨实例 /stop 若不校验会误杀无辜。校验失败按「不是会话」处理。
+     */
+    static pidLooksLikeAgent(pid) {
+        try {
+            if (process.platform === 'win32') {
+                const out = (0, child_process_1.execFileSync)('tasklist', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'], {
+                    encoding: 'utf-8',
+                });
+                return /cursor-agent|node|cmd\.exe/i.test(out);
+            }
+            const out = (0, child_process_1.execFileSync)('ps', ['-o', 'command=', '-p', String(pid)], { encoding: 'utf-8' });
+            return /cursor-agent/i.test(out);
+        }
+        catch {
+            return false;
+        }
+    }
+    /** 当前全局是否有活跃会话（锁存在且会话进程活着；死锁视为无会话） */
+    aliveLock() {
+        const lock = this.readLock();
+        if (!lock)
+            return null;
+        // pid=0 = 另一个实例刚抢到锁、spawn 还没完成：以它的实例进程判活，避免这瞬间被当死锁误清
+        const alive = lock.pid > 0
+            ? CliLauncher.pidAlive(lock.pid)
+            : CliLauncher.pidAlive(lock.ownerPid);
+        if (!alive) {
+            // 持锁会话已死（实例崩溃 / 强杀），清掉残锁
+            fs.rmSync(this.lockPath(), { force: true });
+            return null;
+        }
+        return lock;
+    }
+    /** 原子抢锁：wx 独占创建。返回是否抢到（false = 别的实例刚抢先） */
+    tryAcquireLock(task) {
+        // 先清死锁，再独占创建（两个实例同时 /new 时只有一个 wx 成功）
+        this.aliveLock();
+        const lock = { pid: 0, task, startedAt: Date.now(), ownerPid: process.pid };
+        try {
+            fs.mkdirSync(path.dirname(this.lockPath()), { recursive: true });
+            fs.writeFileSync(this.lockPath(), JSON.stringify(lock), { flag: 'wx' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    updateLockPid(pid) {
+        const lock = this.readLock();
+        if (lock && lock.ownerPid === process.pid) {
+            fs.writeFileSync(this.lockPath(), JSON.stringify({ ...lock, pid }));
+        }
+    }
+    releaseLock() {
+        const lock = this.readLock();
+        if (lock && lock.ownerPid === process.pid) {
+            fs.rmSync(this.lockPath(), { force: true });
+        }
+    }
+    /** 全局视角：是否有会话在跑（本实例或其他实例拉起的都算） */
     isRunning() {
-        return this.child !== null;
+        return this.child !== null || this.aliveLock() !== null;
     }
-    /** 正在运行的会话描述（用于「已有会话在跑」的回执） */
+    /** 正在运行的会话描述（用于「已有会话在跑」的回执；含其他实例拉起的会话） */
     describe() {
-        if (!this.child)
-            return '';
-        const mins = Math.round((Date.now() - this.startedAt) / 60000);
-        return `「${this.taskBrief}」（已运行 ${mins} 分钟）`;
+        if (this.child) {
+            const mins = Math.round((Date.now() - this.startedAt) / 60000);
+            return `「${this.taskBrief}」（已运行 ${mins} 分钟）`;
+        }
+        const lock = this.aliveLock();
+        if (lock) {
+            const brief = lock.task.length > 40 ? lock.task.slice(0, 40) + '…' : lock.task;
+            const mins = Math.round((Date.now() - lock.startedAt) / 60000);
+            return `「${brief}」（已运行 ${mins} 分钟，由另一个窗口实例托管）`;
+        }
+        return '';
     }
     settingsPath() {
         return path.join(os.homedir(), '.cursor-feedback', 'cli.json');
@@ -182,17 +280,24 @@ class CliLauncher {
      * @returns 启动失败时返回错误说明字符串；成功返回 null，结果经 onDone 回调
      */
     start(task, cwd, onDone) {
-        if (this.child)
+        if (this.isRunning())
             return '已有一个 CLI 会话在运行：' + this.describe();
+        // 原子抢全局锁：两个实例同时收到 /new 时只有一个能抢到
+        if (!this.tryAcquireLock(task)) {
+            return '已有一个 CLI 会话在运行：' + (this.describe() || '（另一个窗口实例刚刚抢先拉起）');
+        }
         try {
             this.ensureMaxModeOff();
         }
         catch (e) {
+            this.releaseLock();
             return '写入 cli-config.json 失败：' + e;
         }
         const bin = this.findBinary();
-        if (!bin)
+        if (!bin) {
+            this.releaseLock();
             return '找不到 cursor-agent，可通过环境变量 CURSOR_AGENT_PATH 指定路径。';
+        }
         const workDir = fs.existsSync(cwd) ? cwd : os.homedir();
         const prompt = this.buildPrompt(task);
         let stdout = '';
@@ -225,12 +330,14 @@ class CliLauncher {
             });
         }
         catch (e) {
+            this.releaseLock();
             return '拉起 cursor-agent 失败：' + e;
         }
         this.child = child;
         this.startedAt = Date.now();
         this.taskBrief = task.length > 40 ? task.slice(0, 40) + '…' : task;
         this.stopRequested = false;
+        this.updateLockPid(child.pid || 0);
         clog(`CLI 会话已拉起: pid=${child.pid} cwd=${workDir} model=${this.model()}`);
         let timedOut = false;
         const killTimer = setTimeout(() => {
@@ -243,8 +350,12 @@ class CliLauncher {
         const finish = (code) => {
             clearTimeout(killTimer);
             const elapsedMs = Date.now() - this.startedAt;
-            const stopped = this.stopRequested;
+            // 跨实例 /stop 会在锁上打 stopRequested 标记再杀进程，这里一并算「主动终止」
+            const lockAtFinish = this.readLock();
+            const stopped = this.stopRequested ||
+                !!(lockAtFinish && lockAtFinish.ownerPid === process.pid && lockAtFinish.stopRequested);
             this.child = null;
+            this.releaseLock();
             clog(`CLI 会话结束: code=${code} elapsed=${Math.round(elapsedMs / 1000)}s timedOut=${timedOut} stopped=${stopped}`);
             onDone({
                 code,
@@ -263,20 +374,60 @@ class CliLauncher {
         child.on('close', (code) => finish(code));
         return null;
     }
-    /** 用户 /stop 主动终止会话。返回是否有会话被终止。 */
+    /**
+     * 用户 /stop 主动终止会话。返回是否有会话被终止。
+     * 跨实例：会话可能由另一个窗口实例托管（飞书把 /stop 推给了不同实例），
+     * 此时按锁里的 pid 直接终止会话进程，托管实例的 close 回调会自然收尾并回执。
+     */
     stop() {
-        if (!this.child)
-            return false;
-        this.stopRequested = true;
-        CliLauncher.killTree(this.child, 'SIGTERM');
-        // SIGTERM 5s 内没退出则补 SIGKILL
-        const child = this.child;
-        setTimeout(() => {
-            if (this.child === child) {
-                CliLauncher.killTree(child, 'SIGKILL');
+        if (this.child) {
+            this.stopRequested = true;
+            CliLauncher.killTree(this.child, 'SIGTERM');
+            // SIGTERM 5s 内没退出则补 SIGKILL
+            const child = this.child;
+            setTimeout(() => {
+                if (this.child === child) {
+                    CliLauncher.killTree(child, 'SIGKILL');
+                }
+            }, 5000);
+            return true;
+        }
+        const lock = this.aliveLock();
+        if (lock && lock.pid > 0) {
+            if (!CliLauncher.pidLooksLikeAgent(lock.pid)) {
+                // pid 已被无关进程复用（残锁）：清锁但绝不误杀
+                clog(`锁 pid=${lock.pid} 不是 cursor-agent（已被复用），清除残锁`);
+                fs.rmSync(this.lockPath(), { force: true });
+                return false;
+            }
+            clog(`跨实例终止 CLI 会话: pid=${lock.pid}（由 ${lock.ownerPid} 托管）`);
+            try {
+                // 先在锁上打「主动终止」标记，托管实例收尾时据此报「已终止」而非「异常退出」
+                fs.writeFileSync(this.lockPath(), JSON.stringify({ ...lock, stopRequested: true }));
             }
-        }, 5000);
-        return true;
+            catch {
+                // 标记失败只影响收尾文案
+            }
+            try {
+                // 会话进程是托管实例 detached 出来的进程组组长，杀整组
+                if (process.platform === 'win32') {
+                    (0, child_process_1.spawn)('taskkill', ['/pid', String(lock.pid), '/T', '/F'], { stdio: 'ignore' });
+                }
+                else {
+                    try {
+                        process.kill(-lock.pid, 'SIGTERM');
+                    }
+                    catch {
+                        process.kill(lock.pid, 'SIGTERM');
+                    }
+                }
+            }
+            catch {
+                // 进程刚好自己结束了
+            }
+            return true;
+        }
+        return false;
     }
     /**
      * 终止整个进程树：POSIX 杀进程组（detached spawn 后 child.pid 即组长），

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.4.0",
+  "version": "2.4.1",
   "icon": "icon.png",
   "author": "jianger666",
   "license": "MIT",