cursor-feedback 2.3.1 → 2.4.0

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.0](https://github.com/jianger666/cursor-feedback-extension/compare/v2.3.1...v2.4.0) (2026-07-06)
+
+
+### Features
+
+* 飞书 /new 拉起 Cursor CLI 会话 + 常驻守护进程（IDE 关闭可用） ([1d4513e](https://github.com/jianger666/cursor-feedback-extension/commit/1d4513ed29b8050dc92dc1d2632bf9d61912ab71))
+
 ### [2.3.1](https://github.com/jianger666/cursor-feedback-extension/compare/v2.3.0...v2.3.1) (2026-07-06)
 
 

package/README.md

@@ -27,6 +27,8 @@ If you're on Cursor's 500 requests/month plan or another coding plan, every conv
 - 📝 **Markdown Rendering** - Full Markdown support for AI summaries
 - ⏱️ **Auto-retry on Timeout** - 5-minute default timeout, AI automatically re-requests
 - 🔔 **Feishu (Lark) Bridge** - When AI requests feedback, the summary is pushed to Feishu so you can reply right from your phone
+- 📱 **Launch sessions from your phone** - Send `/new task` in Feishu to spawn a Cursor CLI session, no computer access needed
+- 🌙 **Background service** - Optional login daemon: Feishu keeps working with Cursor closed, auto keep-awake on AC power
 - 🌍 **Multi-language** - Supports English, Simplified Chinese, Traditional Chinese
 - 🔒 **Project Isolation** - Multiple windows work independently
 
@@ -260,6 +262,35 @@ Three steps to enable the round-trip:
 
 > **No idle-kill outside Cursor.** Only the Cursor extension keeps the server warm by polling. On every other host the server stays alive purely on the stdio connection: it exits on stdin EOF or parent-process death, and **never** on idle — and it always stays up while a feedback request is still waiting. So a reply that takes several minutes still makes it back.
 
+### Launch CLI sessions from Feishu (/new)
+
+Start a brand-new AI session from your phone, away from the computer. Prerequisite: [Cursor CLI](https://cursor.com/cli) (`cursor-agent`) installed and logged in on the machine.
+
+Send these directly in the bot chat:
+
+| Command | What it does |
+|---------|--------------|
+| `/new task description` | Launch a headless CLI session for the task (in the active window's workspace, or the `/cwd` default) |
+| `/new /abs/path task description` | Launch with an explicit working directory |
+| `/stop` | Terminate the running CLI session |
+| `/model [modelId]` | Show / set the session model (persisted) |
+| `/cwd [dir]` | Show / set the default working directory (persisted) |
+
+- Sessions run in **non-interactive mode** with `maxMode=false` force-written before spawn — on request-based plans each session costs exactly 1 request, never Max billing.
+- The launched agent talks to you through this extension's feedback cards: confirmations and progress reports are pushed to Feishu; just reply to the cards.
+- Put custom rules in `~/.cursor-feedback/cli-rules.md` (e.g. "always reply in Chinese"); they are injected into every `/new` session.
+- When a session ends (done / error / `/stop` / 3-hour cap), a wrap-up message with the final output is sent to Feishu.
+
+### Background service (works without the IDE)
+
+Normally the server process is spawned by Cursor, so closing Cursor drops the Feishu link. Enable the **background service** and a standalone daemon auto-starts at login — messages and `/new` work whether Cursor is open or not:
+
+- **Enable**: the "Background service" toggle in the extension's notification settings, or `npx cursor-feedback@latest install-daemon` (`uninstall-daemon` / `daemon-status` likewise).
+- **How**: the current package is copied to `~/.cursor-feedback/daemon/app` (self-contained, immune to npx cache cleanup); registered as a launchd agent on macOS (auto-restart on crash) or a logon scheduled task on Windows.
+- **Keep-awake**: while on AC power the daemon prevents system sleep (macOS `caffeinate -s`; Windows power assertion). On battery it does nothing. Lock screen never affects background processes.
+- **Typical use**: leave the machine plugged in and locked after work; `/new` from your phone anytime.
+- After upgrading the extension, toggle the switch off/on once to refresh the daemon's copy.
+
 ## 🏗️ Architecture
 
 ```

package/README_CN.md

@@ -29,6 +29,8 @@
 - 📝 **Markdown 渲染** - AI 摘要支持完整的 Markdown 格式
 - ⏱️ **超时自动重试** - 默认 5 分钟超时，超时后 AI 会自动重新请求反馈
 - 🔔 **飞书打通** - AI 请求反馈时把摘要推送到飞书，你直接在手机上回复，不用守在电脑前
+- 📱 **手机拉起会话** - 飞书发 `/new 任务` 直接拉起一轮 Cursor CLI 会话，人不在电脑前也能开工
+- 🌙 **常驻服务** - 可选的开机自启守护进程：Cursor 不开也能收发飞书消息，接电源自动防睡眠
 - 🌍 **多语言支持** - 支持简体中文、繁体中文和英文
 - 🔒 **项目隔离** - 多窗口同时使用时，各项目互不干扰
 
@@ -264,6 +266,35 @@ npm install -g cursor-feedback
 
 > **非 Cursor 环境不会因空闲被杀。** 只有 Cursor 插件会靠轮询给 server「续命」。在其他所有 host 上，server 完全依赖 stdio 连接存活：只在 stdin EOF 或父进程死亡时退出，**绝不**因空闲退出；而且只要还有反馈在等用户，任何环境都不会退。所以你回复花了好几分钟，结果照样能回到 Agent。
 
+### 手机飞书拉起 CLI 会话（/new）
+
+人不在电脑前，也能从手机飞书发起一轮全新的 AI 会话。前提：本机装好并登录过 [Cursor CLI](https://cursor.com/cli)（`cursor-agent`）。
+
+在与机器人的会话里直接发：
+
+| 命令 | 作用 |
+|------|------|
+| `/new 任务描述` | 拉起一个 headless CLI 会话跑这个任务（默认在活跃窗口工作区 / `/cwd` 设置的目录） |
+| `/new /绝对路径 任务描述` | 指定工作目录拉起 |
+| `/stop` | 终止运行中的 CLI 会话 |
+| `/model [模型id]` | 查看 / 设置会话模型（持久化） |
+| `/cwd [目录]` | 查看 / 设置默认工作目录（持久化） |
+
+- 会话以**非交互模式**运行，拉起前强制写入 `maxMode=false`——按次计费套餐固定只扣 1 次请求，永远不会走 Max 计费。
+- 拉起的 Agent 也通过本插件的反馈卡片与你沟通：需要确认、汇报进展都会推到飞书，直接回复卡片即可。
+- 可在 `~/.cursor-feedback/cli-rules.md` 写自定义规则（如「永远用中文」），每次 `/new` 自动注入。
+- 会话结束（完成 / 异常 / `/stop` / 超 3 小时兜底终止）都会发飞书收尾消息附最终输出。
+
+### 常驻服务（IDE 关闭也可用）
+
+默认情况下 server 进程由 Cursor 拉起，Cursor 一关飞书链路就断。打开**常驻服务**后，一个独立的守护进程会开机自启，Cursor 开不开都能收发飞书消息、响应 `/new`：
+
+- **开启方式**：插件面板「通知设置」里打开「常驻服务」开关；或命令行 `npx cursor-feedback@latest install-daemon`（卸载对应 `uninstall-daemon`，状态 `daemon-status`）。
+- **实现**：把当前包完整拷贝到 `~/.cursor-feedback/daemon/app`（自包含，不怕 npx 缓存被清），macOS 注册 launchd（崩溃自动拉起），Windows 注册登录计划任务。
+- **防睡眠**：守护进程在接电源时自动阻止系统睡眠（macOS `caffeinate -s`；Windows 电源断言），电池供电不生效、不偷耗电。锁屏本来就不影响后台进程。
+- **典型用法**：下班插着电源锁屏走人，手机飞书随时 `/new`。
+- 升级插件版本后重新开关一次即可更新守护进程里的拷贝。
+
 ## 🏗️ 架构
 
 ```

package/dist/cli-launcher.js

@@ -0,0 +1,318 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliLauncher = void 0;
+/**
+ * CLI 会话拉起器：飞书 /new 命令 → 非交互模式 spawn cursor-agent。
+ *
+ * 关键设计（均来自实测结论，勿随意更改）：
+ * - 必须用非交互 print 模式（-p）：交互式 TUI 会话对 Fable 5 会强制回到 Max Mode，
+ *   次数计费的套餐一次对话被扣 10+ 次；非交互模式尊重 cli-config.json 的 maxMode=false，
+ *   固定只扣 1 次请求。
+ * - spawn 前每次都强制把 ~/.cursor/cli-config.json 写成 maxMode=false + 目标模型：
+ *   交互式会话会把这个文件改回 max，不能信任上次的残留状态。
+ * - CLI 不读 IDE 的全局 User Rules，用户的个人规则要显式注入到 prompt 里
+ *   （从 ~/.cursor-feedback/cli-rules.md 读取，没有则只注入 cursor-feedback 沟通协议）。
+ * - 拉起的 agent 会通过全局注册的 cursor-feedback MCP 发飞书卡片，用户在手机上
+ *   直接和这个会话对话——本模块只负责拉起和收尾，过程中的交互走既有反馈链路。
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+function clog(message) {
+    console.error(`[${new Date().toISOString()}] [cli-launcher] ${message}`);
+}
+class CliLauncher {
+    constructor() {
+        this.child = null;
+        this.startedAt = 0;
+        this.taskBrief = '';
+        this.stopRequested = false;
+    }
+    isRunning() {
+        return this.child !== null;
+    }
+    /** 正在运行的会话描述（用于「已有会话在跑」的回执） */
+    describe() {
+        if (!this.child)
+            return '';
+        const mins = Math.round((Date.now() - this.startedAt) / 60000);
+        return `「${this.taskBrief}」（已运行 ${mins} 分钟）`;
+    }
+    settingsPath() {
+        return path.join(os.homedir(), '.cursor-feedback', 'cli.json');
+    }
+    readSettings() {
+        try {
+            const j = JSON.parse(fs.readFileSync(this.settingsPath(), 'utf-8'));
+            return typeof j === 'object' && j ? j : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    writeSettings(patch) {
+        const merged = { ...this.readSettings(), ...patch };
+        const p = this.settingsPath();
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(merged, null, 2));
+    }
+    /** 当前生效模型：env 覆盖 > /model 持久化设置 > 默认。无论选什么模型，spawn 前都强制 maxMode=false */
+    model() {
+        return (process.env.CURSOR_FEEDBACK_CLI_MODEL ||
+            this.readSettings().model ||
+            CliLauncher.DEFAULT_MODEL);
+    }
+    /** /cwd 设置的默认工作目录（存在才返回） */
+    defaultCwd() {
+        const d = this.readSettings().defaultCwd;
+        if (d && fs.existsSync(d))
+            return d;
+        return null;
+    }
+    /**
+     * 定位 cursor-agent 可执行文件。安装脚本默认放在 ~/.local/bin（mac/linux 是
+     * cursor-agent，Windows 是 cursor-agent.cmd/.exe），而 MCP server 进程的 PATH
+     * 通常不含它，不能只靠 PATH 兜底。
+     */
+    findBinary() {
+        const explicit = process.env.CURSOR_AGENT_PATH;
+        if (explicit && fs.existsSync(explicit))
+            return explicit;
+        const names = process.platform === 'win32'
+            ? ['cursor-agent.cmd', 'cursor-agent.exe', 'cursor-agent.ps1']
+            : ['cursor-agent'];
+        for (const dir of [
+            path.join(os.homedir(), '.local', 'bin'),
+            path.join(os.homedir(), 'AppData', 'Local', 'Programs', 'cursor-agent'),
+        ]) {
+            for (const name of names) {
+                const p = path.join(dir, name);
+                if (fs.existsSync(p))
+                    return p;
+            }
+        }
+        return 'cursor-agent'; // 最后交给 PATH 解析，spawn error 时报错提示
+    }
+    /**
+     * spawn 前强制写 cli-config.json：maxMode=false + 目标模型。
+     * 每次都写——交互式会话会把它改回 max，残留状态不可信。
+     */
+    ensureMaxModeOff() {
+        const p = path.join(os.homedir(), '.cursor', 'cli-config.json');
+        let cfg = {};
+        try {
+            cfg = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        }
+        catch {
+            // 文件不存在或损坏时从空对象重建（cursor-agent 会补齐其余字段）
+        }
+        cfg.maxMode = false;
+        cfg.model = { modelId: this.model(), maxMode: false };
+        cfg.hasChangedDefaultModel = true;
+        fs.writeFileSync(p, JSON.stringify(cfg, null, 2));
+        clog(`cli-config.json 已写入 maxMode=false, model=${this.model()}`);
+    }
+    /** 用户自定义注入规则：~/.cursor-feedback/cli-rules.md（可选） */
+    readUserRules() {
+        try {
+            const p = path.join(os.homedir(), '.cursor-feedback', 'cli-rules.md');
+            const text = fs.readFileSync(p, 'utf-8').trim();
+            return text;
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * 组装最终 prompt：cursor-feedback 沟通协议（必注入，否则 headless 会话无法与
+     * 手机上的用户交互）+ 用户自定义规则 + 任务本体。
+     */
+    buildPrompt(task) {
+        const parts = [];
+        parts.push('【会话背景与必须遵守的沟通协议】\n' +
+            '- 用户不在电脑前，正通过手机飞书与你交流；你是被飞书 /new 命令拉起的 headless 会话。\n' +
+            '- 与用户的所有沟通必须通过 MCP 工具 cursor-feedback 的 interactive_feedback 进行' +
+            '（它的卡片会推送到用户飞书）：需要确认、汇报进展、完成任务时都调用它。\n' +
+            '- interactive_feedback 返回以 [TIMEOUT_KEEP_WAITING] 开头时表示用户暂未回复，' +
+            '必须立即用相同 project_directory 再次调用继续等待；以 [TIMEOUT_END] 开头才可结束。\n' +
+            '- project_directory 参数固定传当前工作目录。');
+        const userRules = this.readUserRules();
+        if (userRules) {
+            parts.push('【用户附加规则（必须遵守）】\n' + userRules);
+        }
+        parts.push('【任务】\n' + task);
+        return parts.join('\n\n');
+    }
+    /**
+     * 拉起一个非交互 CLI 会话。调用方需先用 isRunning() 确认没有并发会话。
+     * @returns 启动失败时返回错误说明字符串；成功返回 null，结果经 onDone 回调
+     */
+    start(task, cwd, onDone) {
+        if (this.child)
+            return '已有一个 CLI 会话在运行：' + this.describe();
+        try {
+            this.ensureMaxModeOff();
+        }
+        catch (e) {
+            return '写入 cli-config.json 失败：' + e;
+        }
+        const bin = this.findBinary();
+        if (!bin)
+            return '找不到 cursor-agent，可通过环境变量 CURSOR_AGENT_PATH 指定路径。';
+        const workDir = fs.existsSync(cwd) ? cwd : os.homedir();
+        const prompt = this.buildPrompt(task);
+        let stdout = '';
+        let stderr = '';
+        const append = (buf, chunk) => {
+            const next = buf + chunk.toString();
+            return next.length > CliLauncher.OUTPUT_TAIL_LIMIT
+                ? next.slice(next.length - CliLauncher.OUTPUT_TAIL_LIMIT)
+                : next;
+        };
+        const args = ['-p', '--trust', '--model', this.model(), prompt];
+        const isWin = process.platform === 'win32';
+        // Windows 上 .cmd/.ps1 不能直接 spawn（Node 18.20+ 禁止），需经 cmd.exe 转发
+        const viaCmdShell = isWin && /\.(cmd|bat|ps1)$/i.test(bin);
+        const spawnBin = viaCmdShell ? 'cmd.exe' : bin;
+        const spawnArgs = viaCmdShell ? ['/d', '/s', '/c', bin, ...args] : args;
+        const pathSep = isWin ? ';' : ':';
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(spawnBin, spawnArgs, {
+                cwd: workDir,
+                env: {
+                    ...process.env,
+                    PATH: `${path.join(os.homedir(), '.local', 'bin')}${pathSep}${process.env.PATH || ''}`,
+                },
+                stdio: ['ignore', 'pipe', 'pipe'],
+                // POSIX：独立进程组，终止时连 cursor-agent 自己 spawn 的子进程一起杀干净；
+                // Windows 走 taskkill /T，不需要 detached
+                detached: !isWin,
+            });
+        }
+        catch (e) {
+            return '拉起 cursor-agent 失败：' + e;
+        }
+        this.child = child;
+        this.startedAt = Date.now();
+        this.taskBrief = task.length > 40 ? task.slice(0, 40) + '…' : task;
+        this.stopRequested = false;
+        clog(`CLI 会话已拉起: pid=${child.pid} cwd=${workDir} model=${this.model()}`);
+        let timedOut = false;
+        const killTimer = setTimeout(() => {
+            timedOut = true;
+            clog('会话超过时长上限，强制终止');
+            CliLauncher.killTree(child, 'SIGKILL');
+        }, CliLauncher.SESSION_MAX_MS);
+        child.stdout?.on('data', (chunk) => { stdout = append(stdout, chunk); });
+        child.stderr?.on('data', (chunk) => { stderr = append(stderr, chunk); });
+        const finish = (code) => {
+            clearTimeout(killTimer);
+            const elapsedMs = Date.now() - this.startedAt;
+            const stopped = this.stopRequested;
+            this.child = null;
+            clog(`CLI 会话结束: code=${code} elapsed=${Math.round(elapsedMs / 1000)}s timedOut=${timedOut} stopped=${stopped}`);
+            onDone({
+                code,
+                output: stdout.trim(),
+                errorOutput: stderr.trim(),
+                timedOut,
+                stopped,
+                elapsedMs,
+            });
+        };
+        child.on('error', (err) => {
+            // spawn 失败（如二进制不存在）也走统一收尾，错误进 errorOutput
+            stderr = append(stderr, Buffer.from(String(err)));
+            finish(null);
+        });
+        child.on('close', (code) => finish(code));
+        return null;
+    }
+    /** 用户 /stop 主动终止会话。返回是否有会话被终止。 */
+    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');
+            }
+        }, 5000);
+        return true;
+    }
+    /**
+     * 终止整个进程树：POSIX 杀进程组（detached spawn 后 child.pid 即组长），
+     * Windows 用 taskkill /T 递归终止，连 agent 自己拉的子进程一起清理。
+     */
+    static killTree(child, signal) {
+        if (!child.pid)
+            return;
+        if (process.platform === 'win32') {
+            try {
+                (0, child_process_1.spawn)('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
+            }
+            catch {
+                try {
+                    child.kill();
+                }
+                catch { /* 进程可能已退出 */ }
+            }
+            return;
+        }
+        try {
+            process.kill(-child.pid, signal);
+        }
+        catch {
+            try {
+                child.kill(signal);
+            }
+            catch { /* 进程可能已退出 */ }
+        }
+    }
+}
+exports.CliLauncher = CliLauncher;
+/** 默认模型：实测非交互模式下该模型 + maxMode=false 固定扣 1 次请求 */
+CliLauncher.DEFAULT_MODEL = 'claude-fable-5-thinking-max';
+/** 会话时长兜底：防止无人回复的 headless 会话无限续期挂着 */
+CliLauncher.SESSION_MAX_MS = 3 * 60 * 60 * 1000;
+/** stdout/stderr 只保留尾部，防止长会话把内存吃爆 */
+CliLauncher.OUTPUT_TAIL_LIMIT = 16000;
+//# sourceMappingURL=cli-launcher.js.map