cursor-feedback 2.3.1 → 2.4.1

package/dist/daemon-install.js

@@ -0,0 +1,292 @@
+"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.daemonSupported = daemonSupported;
+exports.installDaemon = installDaemon;
+exports.uninstallDaemon = uninstallDaemon;
+exports.daemonStatus = daemonStatus;
+/**
+ * 常驻守护进程的安装 / 卸载 / 状态查询。
+ *
+ * 目标：Cursor（IDE）不开时飞书链路依然可用——server 以 standalone 守护方式开机自启。
+ *
+ * 安装策略：把「当前正在运行的这份包」（dist + package.json + 依赖 node_modules）
+ * 完整复制到 ~/.cursor-feedback/daemon/app/，自启配置指向这份拷贝。
+ * 为什么复制而不是原地引用：npx 缓存路径会被 npm 清理、扩展目录随版本升级变化，
+ * 原地引用会让守护进程某天悄悄失联；拷贝是自包含的，升级时重装一次即可覆盖。
+ *
+ * 平台注册方式：
+ * - macOS：~/Library/LaunchAgents/<label>.plist（launchd：开机自启 + 崩溃自动拉起）
+ * - Windows：schtasks 登录触发计划任务（无需管理员），经 wscript + vbs 隐藏窗口启动
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const LABEL = 'com.jianger666.cursor-feedback.daemon';
+const WIN_TASK_NAME = 'CursorFeedbackDaemon';
+function dlog(message) {
+    console.error(`[${new Date().toISOString()}] [daemon-install] ${message}`);
+}
+function daemonRoot() {
+    return path.join(os.homedir(), '.cursor-feedback', 'daemon');
+}
+function appRoot() {
+    return path.join(daemonRoot(), 'app');
+}
+function entryPath() {
+    return path.join(appRoot(), 'dist', 'mcp-server.js');
+}
+function plistPath() {
+    return path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+}
+function logPath() {
+    return path.join(daemonRoot(), 'daemon.log');
+}
+/**
+ * 定位真实 node 可执行文件。MCP server 经 npx 启动时 execPath 就是 node；
+ * 万一是在 Electron 里跑（异常场景），回退常见安装路径。
+ */
+function findNode() {
+    const exec = process.execPath;
+    const base = path.basename(exec).toLowerCase();
+    if (base === 'node' || base === 'node.exe')
+        return exec;
+    const candidates = process.platform === 'win32'
+        ? ['C:\\Program Files\\nodejs\\node.exe']
+        : ['/usr/local/bin/node', '/opt/homebrew/bin/node', '/usr/bin/node'];
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return c;
+    }
+    return exec; // 死马当活马：Electron 也能靠 ELECTRON_RUN_AS_NODE 跑 node 脚本
+}
+/** 运行中的这份包的根目录（dist 的上一级） */
+function currentPkgRoot() {
+    // __dirname 编译后是 <pkgRoot>/dist
+    return path.join(__dirname, '..');
+}
+/**
+ * 把当前包（dist + package.json + 依赖）拷贝到守护目录。
+ * 依赖布局两种：npm/npx 安装时依赖在 pkgRoot 的父级 node_modules；
+ * 源码 / 扩展目录时依赖在 pkgRoot/node_modules。
+ */
+function copySelf() {
+    const pkgRoot = currentPkgRoot();
+    const app = appRoot();
+    fs.rmSync(app, { recursive: true, force: true });
+    fs.mkdirSync(app, { recursive: true });
+    for (const item of ['dist', 'package.json']) {
+        const src = path.join(pkgRoot, item);
+        if (!fs.existsSync(src))
+            throw new Error(`当前包缺少 ${item}（${src}），无法安装守护`);
+        fs.cpSync(src, path.join(app, item), { recursive: true });
+    }
+    const ownDeps = path.join(pkgRoot, 'node_modules');
+    const parentDeps = path.resolve(pkgRoot, '..');
+    let depsSrc = null;
+    if (fs.existsSync(ownDeps)) {
+        depsSrc = ownDeps;
+    }
+    else if (path.basename(parentDeps) === 'node_modules') {
+        depsSrc = parentDeps;
+    }
+    if (!depsSrc)
+        throw new Error('找不到依赖 node_modules，无法安装守护');
+    fs.cpSync(depsSrc, path.join(app, 'node_modules'), {
+        recursive: true,
+        dereference: true,
+        // npm 布局下父级 node_modules 里含 cursor-feedback 自身，跳过避免套娃拷贝
+        filter: (src) => !src.includes(`${path.sep}cursor-feedback${path.sep}`) &&
+            !src.endsWith(`${path.sep}cursor-feedback`),
+    });
+    dlog(`包已拷贝到 ${app}`);
+}
+/* ------------------------------ macOS (launchd) ------------------------------ */
+function buildPlist(node) {
+    const isElectron = !/node(\.exe)?$/i.test(path.basename(node));
+    const envBlock = isElectron
+        ? '  <key>EnvironmentVariables</key>\n  <dict>\n    <key>ELECTRON_RUN_AS_NODE</key>\n    <string>1</string>\n  </dict>\n'
+        : '';
+    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>
+    <string>${node}</string>
+    <string>${entryPath()}</string>
+    <string>--daemon</string>
+  </array>
+${envBlock}  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${logPath()}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath()}</string>
+</dict>
+</plist>
+`;
+}
+function launchctl(args) {
+    try {
+        (0, child_process_1.execFileSync)('launchctl', args, { stdio: 'ignore' });
+    }
+    catch {
+        // bootout 不存在的服务等场景会报错，可忽略
+    }
+}
+function installMac() {
+    const node = findNode();
+    const plist = plistPath();
+    fs.mkdirSync(path.dirname(plist), { recursive: true });
+    fs.writeFileSync(plist, buildPlist(node));
+    const uid = process.getuid ? process.getuid() : 501;
+    // 先卸旧再装新（重装 / 升级场景）；bootstrap 失败回退老接口 load
+    launchctl(['bootout', `gui/${uid}/${LABEL}`]);
+    try {
+        (0, child_process_1.execFileSync)('launchctl', ['bootstrap', `gui/${uid}`, plist], { stdio: 'ignore' });
+    }
+    catch {
+        launchctl(['load', '-w', plist]);
+    }
+    dlog('launchd 守护已注册并启动');
+}
+function uninstallMac() {
+    const uid = process.getuid ? process.getuid() : 501;
+    launchctl(['bootout', `gui/${uid}/${LABEL}`]);
+    fs.rmSync(plistPath(), { force: true });
+    dlog('launchd 守护已卸载');
+}
+/* ------------------------------ Windows (schtasks) ------------------------------ */
+function vbsPath() {
+    return path.join(daemonRoot(), 'daemon-launch.vbs');
+}
+function installWin() {
+    const node = findNode();
+    // vbs 包装：schtasks 直接跑控制台程序会闪黑窗，wscript + Run(...,0) 完全隐藏
+    const vbs = `CreateObject("Wscript.Shell").Run """${node}"" ""${entryPath()}"" --daemon", 0, False\r\n`;
+    fs.mkdirSync(daemonRoot(), { recursive: true });
+    fs.writeFileSync(vbsPath(), vbs);
+    try {
+        (0, child_process_1.execFileSync)('schtasks', ['/Delete', '/TN', WIN_TASK_NAME, '/F'], { stdio: 'ignore' });
+    }
+    catch {
+        // 任务不存在
+    }
+    (0, child_process_1.execFileSync)('schtasks', ['/Create', '/TN', WIN_TASK_NAME, '/SC', 'ONLOGON', '/TR', `wscript.exe "${vbsPath()}"`, '/RL', 'LIMITED', '/F'], { stdio: 'ignore' });
+    // 立即拉起一次（不等下次登录）
+    try {
+        (0, child_process_1.execFileSync)('schtasks', ['/Run', '/TN', WIN_TASK_NAME], { stdio: 'ignore' });
+    }
+    catch {
+        (0, child_process_1.spawn)('wscript.exe', [vbsPath()], { stdio: 'ignore', detached: true }).unref();
+    }
+    dlog('Windows 计划任务已注册并启动');
+}
+function uninstallWin() {
+    try {
+        (0, child_process_1.execFileSync)('schtasks', ['/Delete', '/TN', WIN_TASK_NAME, '/F'], { stdio: 'ignore' });
+    }
+    catch {
+        // 任务不存在
+    }
+    fs.rmSync(vbsPath(), { force: true });
+    dlog('Windows 计划任务已卸载');
+}
+/* ------------------------------ 公共入口 ------------------------------ */
+function daemonSupported() {
+    return process.platform === 'darwin' || process.platform === 'win32';
+}
+function installDaemon() {
+    if (!daemonSupported())
+        throw new Error(`平台 ${process.platform} 暂不支持常驻守护`);
+    copySelf();
+    if (process.platform === 'darwin')
+        installMac();
+    else
+        installWin();
+    return daemonStatus();
+}
+function uninstallDaemon() {
+    if (process.platform === 'darwin')
+        uninstallMac();
+    else if (process.platform === 'win32')
+        uninstallWin();
+    fs.rmSync(appRoot(), { recursive: true, force: true });
+    return daemonStatus();
+}
+function daemonStatus() {
+    const registered = process.platform === 'darwin'
+        ? fs.existsSync(plistPath())
+        : process.platform === 'win32'
+            ? winTaskExists()
+            : false;
+    const entry = entryPath();
+    const installed = registered && fs.existsSync(entry);
+    let installedVersion = null;
+    if (installed) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(appRoot(), 'package.json'), 'utf-8'));
+            installedVersion = typeof pkg.version === 'string' ? pkg.version : null;
+        }
+        catch {
+            // 读不到版本不影响状态
+        }
+    }
+    return {
+        supported: daemonSupported(),
+        installed,
+        installedVersion,
+        entryPath: installed ? entry : null,
+    };
+}
+function winTaskExists() {
+    try {
+        (0, child_process_1.execFileSync)('schtasks', ['/Query', '/TN', WIN_TASK_NAME], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=daemon-install.js.map

package/dist/extension.js

@@ -297,6 +297,12 @@ class FeedbackViewProvider {
                 case 'toggleFeishuQueue':
                     await this._handleToggleFeishuQueue(!!data.payload?.enabled);
                     break;
+                case 'requestDaemonStatus':
+                    await this._handleRequestDaemonStatus();
+                    break;
+                case 'toggleDaemon':
+                    await this._handleToggleDaemon(!!data.payload?.enabled);
+                    break;
                 case 'feishuRegisterStart':
                     await this._handleFeishuRegisterStart();
                     break;
@@ -1332,6 +1338,60 @@ class FeedbackViewProvider {
         this._broadcastFeishuConfig();
         this._postFeishuState();
     }
+    /** 找一个活跃的 server 端口（常驻服务安装/状态查询走任一进程均可，磁盘配置全局共享） */
+    _anyServerPort() {
+        if (this._activePort)
+            return this._activePort;
+        const ports = this._debugInfo.connectedPorts || [];
+        return ports.length > 0 ? ports[0] : null;
+    }
+    /** 查询常驻服务状态并回显到设置面板 */
+    async _handleRequestDaemonStatus() {
+        const port = this._anyServerPort();
+        if (!port) {
+            this._view?.webview.postMessage({
+                type: 'daemonState',
+                payload: { supported: false, installed: false, error: 'no server' },
+            });
+            return;
+        }
+        try {
+            const raw = await this._httpGet(`http://127.0.0.1:${port}/api/daemon/status`);
+            this._view?.webview.postMessage({ type: 'daemonState', payload: JSON.parse(raw) });
+        }
+        catch (e) {
+            this._view?.webview.postMessage({
+                type: 'daemonState',
+                payload: { supported: true, installed: false, error: String(e) },
+            });
+        }
+    }
+    /** 安装/卸载常驻服务（server 端执行：拷贝自身 + 注册开机自启），完成后回显状态 */
+    async _handleToggleDaemon(enabled) {
+        const port = this._anyServerPort();
+        if (!port) {
+            this._view?.webview.postMessage({
+                type: 'daemonState',
+                payload: { supported: true, installed: !enabled, error: 'no server' },
+            });
+            return;
+        }
+        try {
+            // 安装要拷贝整棵依赖树，超时放宽到 60s
+            const raw = await this._httpPost(`http://127.0.0.1:${port}/api/daemon/${enabled ? 'install' : 'uninstall'}`, '{}', 60000);
+            const parsed = JSON.parse(raw);
+            this._view?.webview.postMessage({
+                type: 'daemonState',
+                payload: parsed.error ? { supported: true, installed: !enabled, error: parsed.error } : parsed,
+            });
+        }
+        catch (e) {
+            this._view?.webview.postMessage({
+                type: 'daemonState',
+                payload: { supported: true, installed: !enabled, error: String(e) },
+            });
+        }
+    }
     /**
      * HTTP GET 请求
      */

package/dist/i18n/en.json

@@ -74,6 +74,12 @@
   "feishuAckDesc": "After you reply in Feishu, the bot adds a Get emoji as acknowledgement.",
   "queueWhenBusyLabel": "Queue messages while AI is busy",
   "queueWhenBusyDesc": "While the AI is busy, messages from the panel and Feishu are queued and auto-delivered in order on its next feedback round, marked as appended during the task.",
+  "daemonLabel": "Background service (works without IDE)",
+  "daemonDesc": "Auto-start a standalone Feishu bridge at login: receive messages and launch CLI sessions with /new even when Cursor is closed. Keeps the machine awake while plugged in.",
+  "daemonInstalled": "Installed v{version}",
+  "daemonNotSupported": "Not supported on this platform",
+  "daemonFailed": "Operation failed: {error}",
+  "daemonWorking": "Working…",
   "queueSend": "Queue Message",
   "queuedTitle": "Queued messages",
   "queueModeHint": "AI is busy — messages sent now are queued and delivered when it next asks for feedback",

package/dist/i18n/index.js

@@ -165,6 +165,12 @@ function getDefaultMessages() {
         feishuAckDesc: "After you reply in Feishu, the bot adds a Get emoji as acknowledgement.",
         queueWhenBusyLabel: "Queue messages while AI is busy",
         queueWhenBusyDesc: "While the AI is busy, messages from the panel and Feishu are queued and auto-delivered in order on its next feedback round, marked as appended during the task.",
+        daemonLabel: "Background service (works without IDE)",
+        daemonDesc: "Auto-start a standalone Feishu bridge at login: receive messages and launch CLI sessions with /new even when Cursor is closed. Keeps the machine awake while plugged in.",
+        daemonInstalled: "Installed v{version}",
+        daemonNotSupported: "Not supported on this platform",
+        daemonFailed: "Operation failed: {error}",
+        daemonWorking: "Working…",
         queueSend: "Queue Message",
         queuedTitle: "Queued messages",
         queueModeHint: "AI is busy — messages sent now are queued and delivered when it next asks for feedback",

package/dist/i18n/zh-CN.json

@@ -74,6 +74,12 @@
   "feishuAckDesc": "你在飞书回复后，机器人加个 Get 表情表示「已收到」。",
   "queueWhenBusyLabel": "忙时消息排队",
   "queueWhenBusyDesc": "AI 正忙时，面板与飞书发送的消息先排队，等它下一轮询问时按序自动送达，并附「任务期间追加」提示。",
+  "daemonLabel": "常驻服务（IDE 关闭也可用）",
+  "daemonDesc": "开机自启一个独立的飞书桥接进程：Cursor 不开也能收发飞书消息、用 /new 从手机拉起 CLI 会话；接电源时自动防睡眠（锁屏不受影响）。",
+  "daemonInstalled": "已安装 v{version}",
+  "daemonNotSupported": "当前平台暂不支持",
+  "daemonFailed": "操作失败：{error}",
+  "daemonWorking": "处理中…",
   "queueSend": "排队发送",
   "queuedTitle": "排队中的消息",
   "queueModeHint": "AI 正忙，现在发送的消息会排队，等它下一轮询问时自动送达",

package/dist/keep-awake.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeepAwake = void 0;
+/**
+ * 防睡眠模块：常驻守护进程启用，保证「下班锁屏后手机随时能唤起」。
+ *
+ * 原则：只在接电源时阻止系统睡眠，绝不偷耗电池；锁屏/关屏不受影响（本来就不断网）。
+ * - macOS：拉一个 `caffeinate -s` 子进程。-s 语义本身就是「仅接电时阻止系统睡眠」，
+ *   电池供电时自动不生效，无需自己轮询电源状态；进程退出断言自动释放。
+ * - Windows：拉一个 PowerShell 子进程调 Win32 SetThreadExecutionState(
+ *   ES_CONTINUOUS | ES_SYSTEM_REQUIRED)。API 本身不区分电源，故脚本内每 30s 轮询
+ *   电池状态，接电才持有断言、拔电立即释放。无需管理员、不改用户电源计划，
+ *   进程退出断言自动失效。
+ */
+const child_process_1 = require("child_process");
+function klog(message) {
+    console.error(`[${new Date().toISOString()}] [keep-awake] ${message}`);
+}
+/**
+ * Windows 常驻脚本：持有/释放电源断言 + 电源状态轮询。
+ * ES_CONTINUOUS=0x80000000, ES_SYSTEM_REQUIRED=0x00000001。
+ * PowerLineStatus: Online=接电（台式机无电池也是 Online）。
+ */
+const WIN_KEEP_AWAKE_PS = `
+Add-Type -Name P -Namespace W -MemberDefinition '[DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint esFlags);'
+Add-Type -AssemblyName System.Windows.Forms
+$held = $false
+while ($true) {
+  $ac = [System.Windows.Forms.SystemInformation]::PowerStatus.PowerLineStatus -eq 'Online'
+  if ($ac -and -not $held) { [W.P]::SetThreadExecutionState(0x80000001) | Out-Null; $held = $true }
+  elseif (-not $ac -and $held) { [W.P]::SetThreadExecutionState(0x80000000) | Out-Null; $held = $false }
+  Start-Sleep -Seconds 30
+}
+`;
+class KeepAwake {
+    constructor() {
+        this.child = null;
+        this.stopped = false;
+    }
+    isActive() {
+        return this.child !== null;
+    }
+    /** 启动防睡眠（幂等）。不支持的平台（Linux 等）静默跳过。 */
+    start() {
+        if (this.child)
+            return;
+        this.stopped = false;
+        let bin;
+        let args;
+        if (process.platform === 'darwin') {
+            bin = '/usr/bin/caffeinate';
+            args = ['-s'];
+        }
+        else if (process.platform === 'win32') {
+            bin = 'powershell.exe';
+            args = ['-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command', WIN_KEEP_AWAKE_PS];
+        }
+        else {
+            klog(`平台 ${process.platform} 暂不支持防睡眠，跳过`);
+            return;
+        }
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(bin, args, { stdio: 'ignore' });
+        }
+        catch (e) {
+            klog('启动防睡眠子进程失败: ' + e);
+            return;
+        }
+        this.child = child;
+        klog(`防睡眠已启动: pid=${child.pid}（仅接电源时阻止系统睡眠）`);
+        child.on('error', (err) => {
+            klog('防睡眠子进程出错: ' + err);
+            this.child = null;
+        });
+        child.on('exit', () => {
+            this.child = null;
+            // 意外退出（如被任务管理器杀掉）时自动重启，保证常驻语义；主动 stop 不重启
+            if (!this.stopped) {
+                klog('防睡眠子进程意外退出，10s 后重启');
+                setTimeout(() => {
+                    if (!this.stopped)
+                        this.start();
+                }, 10000);
+            }
+        });
+    }
+    stop() {
+        this.stopped = true;
+        if (!this.child)
+            return;
+        try {
+            this.child.kill();
+        }
+        catch { /* 进程可能已退出 */ }
+        this.child = null;
+        klog('防睡眠已停止');
+    }
+}
+exports.KeepAwake = KeepAwake;
+//# sourceMappingURL=keep-awake.js.map