cursor-feedback 2.1.2 → 2.3.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 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.3.0](https://github.com/jianger666/cursor-feedback-extension/compare/v2.2.0...v2.3.0) (2026-07-04)
+
+
+### Features
+
+* 面板消息排队与撤回、扫码建应用、摘要历史与多项 UI 体验优化 ([ffe731c](https://github.com/jianger666/cursor-feedback-extension/commit/ffe731c767975f2045fc4b8701500b6a60f48373))
+
+## [2.2.0](https://github.com/jianger666/cursor-feedback-extension/compare/v2.1.2...v2.2.0) (2026-07-03)
+
+
+### Features
+
+* **feishu:** 忙时消息排队——AI 干活期间的飞书消息不再丢失 ([fd8aa75](https://github.com/jianger666/cursor-feedback-extension/commit/fd8aa7540a787dbb44e85f35ea137a0c0ea9c03e))
+
 ### [2.1.2](https://github.com/jianger666/cursor-feedback-extension/compare/v2.1.1...v2.1.2) (2026-07-03)
 
 

package/README.md

@@ -227,6 +227,7 @@ Either way works — but you first need to set up the bot in the Feishu console:
 | `FEISHU_APP_SECRET` | - | Feishu app App Secret |
 | `FEISHU_ENABLED` | `true` | Whether to push feedback to Feishu. Set to `false` to disable |
 | `FEISHU_ACK` | `true` | Whether to react with a "Get" emoji after you reply. Set to `false` to disable |
+| `FEISHU_QUEUE` | `true` | Queue messages while the AI is busy: messages sent when no feedback request is waiting are queued and auto-delivered on the AI's next feedback round, prefixed with an "appended during the task" hint; the bot acknowledges with a "queued" reply. Set to `false` to disable (also toggleable in the panel's notification settings) |
 
 > Priority: **panel config (when credentials are filled) > env here > default**. The panel wins when App ID/Secret are filled; otherwise it falls back to env. You still need to send the bot one message in Feishu to complete binding.
 

package/README_CN.md

@@ -231,6 +231,7 @@ npm install -g cursor-feedback
 | `FEISHU_APP_SECRET` | - | 飞书应用 App Secret |
 | `FEISHU_ENABLED` | `true` | 是否推送反馈到飞书，设 `false` 关闭 |
 | `FEISHU_ACK` | `true` | 收到你的回复后是否回「Get」表情回执，设 `false` 关闭 |
+| `FEISHU_QUEUE` | `true` | 忙时消息排队：AI 正忙（没有等待中的反馈）时你发的消息先排队，等 AI 下一轮询问时自动送达并附「任务期间追加」提示；排队时机器人会回执「已排队，任务完成后自动读取」。设 `false` 关闭（也可在面板「通知设置」里切换） |
 
 > 优先级：**插件面板（填了凭证）> 这里的 env > 默认**。面板里填了 App ID/Secret 就以面板为准；没填则回退到 env。首次仍需在飞书里给机器人发一条消息完成绑定。
 

package/dist/extension.js

@@ -177,6 +177,11 @@ class FeedbackViewProvider {
         this._feishuEnabled = true;
         // Get 表情回执子开关（飞书通知子项；关掉后用户飞书回复不加 Get 表情、也不发文字兜底）
         this._feishuAck = true;
+        // 忙时消息排队子开关（飞书通知子项；AI 正忙时用户消息入队，下一轮 feedback 自动送达）
+        this._feishuQueue = true;
+        // 最近一次下发给 webview 的队列快照（签名去重避免每秒刷屏；webview 重建后凭此恢复列表）
+        this._lastQueueSig = '';
+        this._lastQueueItems = [];
         this._debugInfo = {
             portRange: '',
             workspacePath: '',
@@ -184,6 +189,9 @@ class FeedbackViewProvider {
             activePort: null,
             lastStatus: ''
         };
+        // ---------- 扫码一键创建飞书应用 ----------
+        this._registerPollTimer = null;
+        this._registerPort = null;
         this._basePort = port;
         this._debugInfo.portRange = `${port}-${port + this._portScanRange - 1}`;
         this._i18n = (0, i18n_1.loadMessages)(this._extensionUri.fsPath);
@@ -194,6 +202,7 @@ class FeedbackViewProvider {
         this._feishuConfig = { appId: fc.appId || '', appSecret: fc.appSecret || '' };
         this._feishuEnabled = this._memento?.get('feishuEnabled', true) ?? true;
         this._feishuAck = this._memento?.get('feishuAck', true) ?? true;
+        this._feishuQueue = this._memento?.get('feishuQueue', true) ?? true;
     }
     /**
      * 获取翻译消息
@@ -225,11 +234,22 @@ class FeedbackViewProvider {
                 case 'submitFeedback':
                     await this._handleFeedbackSubmit(data.payload);
                     break;
+                case 'queueMessage':
+                    await this._handleQueueMessage(data.payload);
+                    break;
+                case 'removeQueued':
+                    await this._handleRemoveQueued(data.payload);
+                    break;
                 case 'ready':
                     this._webviewReady = true;
                     // 同步超时续期开关状态到 UI
                     this._postAutoRetryState();
                     this._postFeishuState();
+                    // 重建后的 webview 恢复队列列表显示（poll 之后每秒还会校准）
+                    this._view?.webview.postMessage({
+                        type: 'queueState',
+                        payload: { items: this._lastQueueItems }
+                    });
                     // WebView 准备就绪后，检查是否有待处理的请求
                     // （插件通知关闭时保持静默，不显示缓存的请求）
                     if (this._currentRequest && this._isPluginNotifyEnabled()) {
@@ -262,9 +282,6 @@ class FeedbackViewProvider {
                 case 'saveFeishuConfig':
                     await this._handleSaveFeishuConfig(data.payload);
                     break;
-                case 'openFeishuGuide':
-                    await this._handleOpenFeishuGuide();
-                    break;
                 case 'toggleFeishuEnabled':
                     await this._handleToggleFeishuEnabled(!!data.payload?.enabled);
                     break;
@@ -277,6 +294,18 @@ class FeedbackViewProvider {
                 case 'toggleFeishuAck':
                     await this._handleToggleFeishuAck(!!data.payload?.enabled);
                     break;
+                case 'toggleFeishuQueue':
+                    await this._handleToggleFeishuQueue(!!data.payload?.enabled);
+                    break;
+                case 'feishuRegisterStart':
+                    await this._handleFeishuRegisterStart();
+                    break;
+                case 'feishuRegisterCancel':
+                    this._handleFeishuRegisterCancel();
+                    break;
+                case 'openLink':
+                    this._handleOpenLink(data.payload?.url);
+                    break;
                 case 'testNotification':
                     this._sendTestNotification();
                     break;
@@ -352,6 +381,8 @@ class FeedbackViewProvider {
                         // 端口仍然有效，保持使用
                         this._debugInfo.connectedPorts = [this._activePort];
                         this._debugInfo.activePort = this._activePort;
+                        // 同步忙时队列快照到面板（签名去重，无变化不发）；打上端口标，撤回时按它路由
+                        this._postQueueState((result.queued || []).map(q => ({ ...q, port: this._activePort })));
                         // 只挡「已提交/已结束」的请求；_handleNewRequest 内部按当前显示态去重，重复调用无害
                         if (result.request && !this._resolvedRequestIds.has(result.request.id)) {
                             this._debugInfo.lastStatus = this._t('statusListening', { port: this._activePort });
@@ -384,6 +415,12 @@ class FeedbackViewProvider {
             const results = await Promise.all(ports.map(port => this._checkPortForRequest(port)));
             // 更新已连接的端口列表
             this._debugInfo.connectedPorts = results.filter(r => r.connected).map(r => r.port);
+            // 汇总各 server 返回的本工作区忙时队列（正常只有归属本窗口的 server 有内容），按时间排序下发；
+            // 打上各自 server 的端口标，撤回时按它路由
+            const queuedAll = results
+                .flatMap(r => (r.connected && Array.isArray(r.queued) ? r.queued.map(q => ({ ...q, port: r.port })) : []))
+                .sort((a, b) => a.at - b.at);
+            this._postQueueState(queuedAll);
             // 找出属于当前工作区的请求（只排除已提交/已结束的；「见过但没提交」的仍要能回到面板）。
             // 不再用 server 进程级 ownerWorkspace 二次过滤：request 已在 _checkPortForRequest
             // 按本窗口工作区过滤过（isPathInWorkspace）；多窗口共用一个 MCP 进程时 owner 只反映
@@ -451,11 +488,14 @@ class FeedbackViewProvider {
             let request;
             let ownerWorkspace = null;
             let feishuResolvedId = null;
+            let queued = [];
             if (parsed && typeof parsed === 'object' && 'startTime' in parsed) {
                 // 新格式
                 request = parsed.request;
                 ownerWorkspace = parsed.ownerWorkspace;
                 feishuResolvedId = parsed.feishuResolvedId ?? null;
+                if (Array.isArray(parsed.queued))
+                    queued = parsed.queued;
                 this._maybeSyncFeishu(port, parsed.feishu);
                 this._maybeSyncAutoRetry(parsed.autoRetry);
                 this._maybeSyncPause(parsed.pause);
@@ -469,10 +509,10 @@ class FeedbackViewProvider {
                 const isMatch = isPathInWorkspace(request.projectDir);
                 if (!isMatch) {
                     // 请求不属于当前工作区，返回特殊标记
-                    return { connected: true, request: null, port, mismatch: true, ownerWorkspace };
+                    return { connected: true, request: null, port, mismatch: true, ownerWorkspace, queued };
                 }
             }
-            return { connected: true, request, port, ownerWorkspace, feishuResolvedId };
+            return { connected: true, request, port, ownerWorkspace, feishuResolvedId, queued };
         }
         catch {
             return { connected: false, request: null, port };
@@ -760,6 +800,103 @@ class FeedbackViewProvider {
             vscode.window.showErrorMessage(this._i18n.submitFailed + ': ' + this._i18n.cannotConnectMCP);
         }
     }
+    /**
+     * 把忙时队列快照推给 webview（签名去重：队列无变化时每秒轮询不重复发）
+     */
+    _postQueueState(items) {
+        const sig = JSON.stringify(items);
+        if (sig === this._lastQueueSig)
+            return;
+        this._lastQueueSig = sig;
+        this._lastQueueItems = items;
+        this._view?.webview.postMessage({ type: 'queueState', payload: { items } });
+    }
+    /**
+     * 面板忙时排队：AI 正忙（没有等待中的反馈请求）时用户在面板点了「排队发送」。
+     * 先定位归属本工作区的 server（AI 的下一轮 interactive_feedback 会走同一个 MCP 进程，
+     * 队列必须排在那里才能被消费），再 POST 入队。找不到归属 server = AI 没在本项目工作，
+     * 明确告知失败，绝不静默吞消息。
+     */
+    async _handleQueueMessage(payload) {
+        const workspacePaths = getWorkspacePaths();
+        const workspacePath = workspacePaths.length > 0 ? workspacePaths[0] : '';
+        const fail = (reason) => {
+            this._view?.webview.postMessage({ type: 'queueSubmitted', payload: { success: false, reason } });
+        };
+        if (!workspacePath) {
+            fail('no-server');
+            return;
+        }
+        const port = await this._findOwnerPort(workspacePath);
+        if (!port) {
+            fail('no-server');
+            return;
+        }
+        try {
+            const response = await this._httpPost(`http://127.0.0.1:${port}/api/feedback/enqueue`, JSON.stringify({
+                text: payload.interactive_feedback,
+                images: payload.images || [],
+                attachedFiles: payload.attachedFiles || [],
+                projectDir: workspacePath
+            }));
+            const result = JSON.parse(response);
+            if (result.queued) {
+                this._view?.webview.postMessage({ type: 'queueSubmitted', payload: { success: true } });
+            }
+            else {
+                fail(result.reason === 'pending' || result.reason === 'disabled' ? result.reason : 'no-server');
+            }
+        }
+        catch {
+            fail('no-server');
+        }
+    }
+    /**
+     * 撤回一条排队消息：按队列项携带的端口路由到所在 server。
+     * webview 已做乐观移除；失败也无需提示——下一秒轮询会把仍在队列里的消息补回列表。
+     */
+    async _handleRemoveQueued(payload) {
+        if (!payload || !payload.id || typeof payload.port !== 'number')
+            return;
+        try {
+            await this._httpPost(`http://127.0.0.1:${payload.port}/api/feedback/queue/remove`, JSON.stringify({ id: payload.id }));
+        }
+        catch {
+            // 静默：轮询会校准列表
+        }
+    }
+    /**
+     * 定位归属指定工作区的 MCP server 端口（ownerWorkspace 与工作区路径互为前缀）。
+     * 优先试当前已知端口，避免全端口扫描；都不中再并行扫描全范围。
+     */
+    async _findOwnerPort(workspacePath) {
+        const normalizedWs = normalizePath(workspacePath);
+        const isOwner = async (port) => {
+            try {
+                const response = await this._httpGet(`http://127.0.0.1:${port}/api/feedback/current?workspace=${encodeURIComponent(workspacePath)}`);
+                const parsed = JSON.parse(response);
+                const owner = parsed && parsed.ownerWorkspace ? normalizePath(parsed.ownerWorkspace) : '';
+                return !!owner && pathsRelated(owner, normalizedWs);
+            }
+            catch {
+                return false;
+            }
+        };
+        const preferred = [this._currentRequestPort, this._activePort]
+            .filter((p) => typeof p === 'number');
+        for (const p of preferred) {
+            if (await isOwner(p))
+                return p;
+        }
+        const ports = [];
+        for (let i = 0; i < this._portScanRange; i++) {
+            const p = this._basePort + i;
+            if (!preferred.includes(p))
+                ports.push(p);
+        }
+        const hits = await Promise.all(ports.map(async (p) => ((await isOwner(p)) ? p : null)));
+        return hits.find((p) => p !== null) ?? null;
+    }
     /**
      * 处理选择文件/文件夹
      */
@@ -973,6 +1110,7 @@ class FeedbackViewProvider {
                 bound: this._feishuBound,
                 feishuEnabled: this._feishuEnabled,
                 feishuAck: this._feishuAck,
+                feishuQueue: this._feishuQueue,
                 systemNotification: !!systemNotification,
                 osNotification: !!osNotification
             }
@@ -1007,6 +1145,7 @@ class FeedbackViewProvider {
         const appSecret = feishuStatus.appSecret || '';
         const enabled = feishuStatus.enabled !== false;
         const ack = feishuStatus.ackReaction !== false;
+        const queue = feishuStatus.queueWhenBusy !== false;
         const bound = !!feishuStatus.boundChatId;
         let changed = false;
         if (appId !== this._feishuConfig.appId || appSecret !== this._feishuConfig.appSecret) {
@@ -1023,6 +1162,10 @@ class FeedbackViewProvider {
             this._feishuAck = ack;
             changed = true;
         }
+        if (queue !== this._feishuQueue) {
+            this._feishuQueue = queue;
+            changed = true;
+        }
         if (bound !== this._feishuBound) {
             this._feishuBound = bound;
             changed = true;
@@ -1041,29 +1184,109 @@ class FeedbackViewProvider {
             appSecret,
             enabled: this._feishuEnabled,
             ackReaction: this._feishuAck,
+            queueWhenBusy: this._feishuQueue,
         });
         for (const port of ports) {
             this._httpPost(`http://127.0.0.1:${port}/api/feishu/config`, body).catch(() => { });
         }
     }
+    _postRegisterState(payload) {
+        this._view?.webview.postMessage({ type: 'feishuRegisterState', payload });
+    }
     /**
-     * 打开「如何配置飞书机器人」指引
+     * 发起扫码创建：找一个活跃的 MCP server（凭证写磁盘全局共享，任一进程均可），
+     * 拿到验证链接后本地生成二维码 dataURL 推给面板，随后轮询直到成功/失败。
      */
-    async _handleOpenFeishuGuide() {
-        const onlineUrl = 'https://github.com/jianger666/cursor-feedback-extension/blob/main/docs/feishu-setup.md';
-        const guideUri = vscode.Uri.joinPath(this._extensionUri, 'docs', 'feishu-setup.md');
+    async _handleFeishuRegisterStart() {
+        this._stopRegisterPolling();
+        const port = await this._findAnyServerPort();
+        if (!port) {
+            this._postRegisterState({ status: 'error', error: this._i18n.registerNoServer });
+            return;
+        }
+        this._registerPort = port;
         try {
-            // 先 stat 确认打进包的本地文档在、再站内预览。
-            // markdown.showPreview 对缺失文件不报错、只渲染「找不到 feishu-setup.md」、catch 也不触发——
-            // 所以必须自己先校验存在、否则一旦打包又漏了 docs 就退回原 bug。
-            await vscode.workspace.fs.stat(guideUri);
-            await vscode.commands.executeCommand('markdown.showPreview', guideUri);
+            // register/start 要等二维码就绪（服务端最多 10s）才响应，超时给足余量。
+            // 二维码 dataURL 由 server 生成（插件 VSIX 不带 node_modules，装不进二维码库）
+            const raw = await this._httpPost(`http://127.0.0.1:${port}/api/feishu/register/start`, '{}', 15000);
+            const state = JSON.parse(raw);
+            if (state.status === 'waiting' && state.url) {
+                this._postRegisterState({ status: 'waiting', url: state.url, expireIn: state.expireIn, qr: state.qr });
+                this._startRegisterPolling(port);
+            }
+            else {
+                this._postRegisterState({ status: 'error', error: state.error || 'failed' });
+            }
         }
         catch {
-            // 本地没有（打包漏了 / 环境异常）→ 兜底开 GitHub 在线文档、绝不让用户再撞「找不到」
-            await vscode.env.openExternal(vscode.Uri.parse(onlineUrl));
+            this._postRegisterState({ status: 'error', error: this._i18n.registerNoServer });
+        }
+    }
+    _handleFeishuRegisterCancel() {
+        this._stopRegisterPolling();
+        if (this._registerPort) {
+            this._httpPost(`http://127.0.0.1:${this._registerPort}/api/feishu/register/cancel`, '{}').catch(() => { });
+            this._registerPort = null;
         }
     }
+    _startRegisterPolling(port) {
+        this._stopRegisterPolling();
+        this._registerPollTimer = setInterval(async () => {
+            try {
+                const raw = await this._httpGet(`http://127.0.0.1:${port}/api/feishu/register/status`);
+                const st = JSON.parse(raw);
+                if (st.status === 'success') {
+                    this._stopRegisterPolling();
+                    this._postRegisterState({ status: 'success', appId: st.appId });
+                }
+                else if (st.status === 'error' || st.status === 'idle') {
+                    this._stopRegisterPolling();
+                    this._postRegisterState({ status: 'error', error: st.error || 'failed' });
+                }
+            }
+            catch {
+                // server 暂时不可达：下一轮再试
+            }
+        }, 2000);
+    }
+    _stopRegisterPolling() {
+        if (this._registerPollTimer) {
+            clearInterval(this._registerPollTimer);
+            this._registerPollTimer = null;
+        }
+    }
+    /** 找任意一个可达的 MCP server 端口（优先当前活跃端口，避免全端口扫描） */
+    async _findAnyServerPort() {
+        const alive = async (port) => {
+            try {
+                const raw = await this._httpGet(`http://127.0.0.1:${port}/api/health`);
+                return JSON.parse(raw).status === 'ok';
+            }
+            catch {
+                return false;
+            }
+        };
+        const preferred = [this._activePort, this._currentRequestPort, ...(this._debugInfo.connectedPorts || [])]
+            .filter((p) => typeof p === 'number');
+        for (const p of preferred) {
+            if (await alive(p))
+                return p;
+        }
+        const ports = [];
+        for (let i = 0; i < this._portScanRange; i++) {
+            const p = this._basePort + i;
+            if (!preferred.includes(p))
+                ports.push(p);
+        }
+        const hits = await Promise.all(ports.map(async (p) => ((await alive(p)) ? p : null)));
+        return hits.find((p) => p !== null) ?? null;
+    }
+    /** 打开外部链接（webview 内点「打开链接」时用；仅放行 http/https） */
+    _handleOpenLink(url) {
+        if (!url || !/^https?:\/\//i.test(url))
+            return;
+        vscode.env.openExternal(vscode.Uri.parse(url));
+    }
     /**
      * 切换飞书通知开关（关了即使已配置也不推飞书；长连接仍保留以便绑定/回复）
      */
@@ -1100,6 +1323,15 @@ class FeedbackViewProvider {
         this._broadcastFeishuConfig();
         this._postFeishuState();
     }
+    /**
+     * 切换「忙时消息排队」子开关（飞书通知的子项；透传到 server 端，控制忙时队列）
+     */
+    async _handleToggleFeishuQueue(enabled) {
+        this._feishuQueue = enabled;
+        await this._memento?.update('feishuQueue', enabled);
+        this._broadcastFeishuConfig();
+        this._postFeishuState();
+    }
     /**
      * HTTP GET 请求
      */
@@ -1120,7 +1352,7 @@ class FeedbackViewProvider {
     /**
      * HTTP POST 请求
      */
-    _httpPost(url, body) {
+    _httpPost(url, body, timeoutMs = 5000) {
         return new Promise((resolve, reject) => {
             const urlObj = new URL(url);
             const options = {
@@ -1132,7 +1364,7 @@ class FeedbackViewProvider {
                     'Content-Type': 'application/json',
                     'Content-Length': Buffer.byteLength(body)
                 },
-                timeout: 5000
+                timeout: timeoutMs
             };
             const req = http.request(options, (res) => {
                 let data = '';

package/dist/feishu.js

@@ -63,6 +63,8 @@ class FeishuBridge {
         this.enabled = true;
         /** Get 表情轻回执开关（false 时用户回复后不加表情、也不发文字兜底） */
         this.ackReaction = true;
+        /** 忙时消息排队开关（true 时 AI 正忙的消息入队等下一轮，false 走旧的短暂存 + 过期提示） */
+        this.queueWhenBusy = true;
         /** 绑定关系（appId -> chat_id）持久化到磁盘：多个 server 进程共享、reload 不丢 */
         this.bindStorePath = path.join(os.homedir(), '.cursor-feedback', 'feishu-bind.json');
         /** 飞书凭证持久化到磁盘：多个 server 进程共享、reload/重启不丢，作为凭证的全局真相源 */
@@ -71,12 +73,18 @@ class FeishuBridge {
         this.cardToRequest = new Map();
         // requestId -> 卡片 message_id（清理用）
         this.requestToCard = new Map();
+        // requestId -> 归属项目空间：请求结束后仍保留（与卡片映射同生命周期），
+        // 供「回复已结束的旧卡片 → 忙时排队到对应项目」定位归属，随 FIFO 上界一起淘汰
+        this.requestProjects = new Map();
         // requestId -> 摘要信息（多窗口「列清单」提示用）
         this.pendingSummaries = new Map();
         /** 收到用户回复时的回调（由 mcp-server 注入，负责路由 / 转发） */
         this.onReply = null;
         /** 绑定的 chat_id 变化时的回调（由 mcp-server 注入，用于通知 extension 持久化） */
         this.onBindChange = null;
+        // ---------- 扫码一键创建应用（registerApp / Device Grant） ----------
+        this.registerState = { status: 'idle' };
+        this.registerAbort = null;
         /** 按 chatId 暂存待合并的入站消息 */
         this.inboundBuffer = new Map();
     }
@@ -92,14 +100,128 @@ class FeishuBridge {
             connected: this.connected,
             enabled: this.enabled,
             ackReaction: this.ackReaction,
+            queueWhenBusy: this.queueWhenBusy,
             appId: this.config?.appId || '',
             appSecret: this.config?.appSecret || '',
             boundChatId: this.getBoundChatId(),
         };
     }
+    isQueueWhenBusy() {
+        return this.queueWhenBusy;
+    }
     isConfigured() {
         return !!this.config;
     }
+    getRegisterState() {
+        return this.registerState;
+    }
+    /**
+     * 启动「扫码一键创建应用」：返回待扫码的验证链接（等 onQRCodeReady 就绪后才返回）。
+     * 用户在飞书里确认后 SDK resolve 出凭证 → 与手动在面板保存等价（写磁盘 touched + configure 立即生效）。
+     * 已有等待中的流程直接复用当前二维码，不重复发起。
+     */
+    async startRegister() {
+        if (this.registerState.status === 'waiting' && this.registerAbort) {
+            return this.registerState;
+        }
+        if (!this.lark) {
+            try {
+                this.lark = await Promise.resolve().then(() => __importStar(require('@larksuiteoapi/node-sdk')));
+            }
+            catch (e) {
+                flog('飞书 SDK 加载失败: ' + e);
+                this.registerState = { status: 'error', error: 'sdk_load_failed' };
+                return this.registerState;
+            }
+        }
+        if (typeof this.lark.registerApp !== 'function') {
+            this.registerState = { status: 'error', error: 'sdk_too_old' };
+            return this.registerState;
+        }
+        const abort = new AbortController();
+        this.registerAbort = abort;
+        const state = { status: 'waiting' };
+        this.registerState = state;
+        let urlResolve = () => { };
+        const urlReady = new Promise((resolve) => {
+            urlResolve = resolve;
+            setTimeout(resolve, 10000); // 兜底：10s 拿不到二维码就按错误返回
+        });
+        this.lark
+            .registerApp({
+            signal: abort.signal,
+            onQRCodeReady: (info) => {
+                state.url = info.url;
+                state.expireIn = info.expireIn;
+                urlResolve();
+            },
+            appPreset: {
+                name: 'Cursor Feedback',
+                desc: 'Cursor AI 交互反馈通知机器人（由 cursor-feedback 插件扫码创建）',
+            },
+            // 平台基础模板已含收发消息 / reaction / 长连接事件；这里增量补齐本插件用到的资源权限。
+            // 平台不认识的名字会在确认页被静默丢弃，不会导致流程失败。
+            addons: {
+                scopes: { tenant: ['im:message', 'im:message:send_as_bot', 'im:resource'] },
+                events: { items: { tenant: ['im.message.receive_v1'] } },
+            },
+            // 只允许创建新应用：避免用户误选已有应用、其配置被覆盖
+            createOnly: true,
+        })
+            .then(async (result) => {
+            if (this.registerState !== state)
+                return; // 已被取消/新流程覆盖
+            const cfg = {
+                appId: result.client_id,
+                appSecret: result.client_secret,
+                enabled: this.enabled,
+                ackReaction: this.ackReaction,
+                queueWhenBusy: this.queueWhenBusy,
+            };
+            this.writePersistedConfig({ ...cfg, touched: true });
+            await this.configure(cfg);
+            state.status = 'success';
+            state.appId = result.client_id;
+            state.url = undefined;
+            flog(`扫码创建应用成功: ${result.client_id}`);
+        })
+            .catch((e) => {
+            if (this.registerState !== state)
+                return;
+            state.status = 'error';
+            state.url = undefined;
+            state.error = [e?.code, e?.description].filter(Boolean).join(': ') || String(e);
+            flog(`扫码创建应用失败: ${state.error}`);
+        });
+        await urlReady;
+        if (state.status === 'waiting' && !state.url) {
+            abort.abort();
+            this.registerAbort = null;
+            this.registerState = { status: 'error', error: 'qr_timeout' };
+            return this.registerState;
+        }
+        // 二维码在 server 侧生成（插件 VSIX 不带 node_modules）；失败则面板退化为只显示链接按钮
+        if (state.status === 'waiting' && state.url) {
+            try {
+                const QRCode = await Promise.resolve().then(() => __importStar(require('qrcode')));
+                state.qr = await QRCode.toDataURL(state.url, { margin: 1, width: 220 });
+            }
+            catch (e) {
+                flog('二维码生成失败（退化为链接）: ' + e);
+            }
+        }
+        return this.registerState;
+    }
+    /** 取消进行中的扫码创建流程（用户关闭弹窗 / 主动取消） */
+    cancelRegister() {
+        if (this.registerAbort) {
+            this.registerAbort.abort();
+            this.registerAbort = null;
+        }
+        if (this.registerState.status === 'waiting') {
+            this.registerState = { status: 'idle' };
+        }
+    }
     /** 读取当前 appId 对应的绑定 chat_id（来自磁盘，跨进程共享） */
     getBoundChatId() {
         if (!this.config?.appId)
@@ -175,9 +297,10 @@ class FeishuBridge {
      * - 凭证为空：视为「关闭飞书」
      */
     async configure(config) {
-        // 通知开关 / Get 表情回执开关随时可改（与凭证无关），总是更新
+        // 通知开关 / Get 表情回执开关 / 排队开关随时可改（与凭证无关），总是更新
         this.enabled = config.enabled !== false;
         this.ackReaction = config.ackReaction !== false;
+        this.queueWhenBusy = config.queueWhenBusy !== false;
         const sameCred = this.config &&
             this.config.appId === config.appId &&
             this.config.appSecret === config.appSecret;
@@ -514,11 +637,14 @@ class FeishuBridge {
                         break;
                     const oldReq = this.cardToRequest.get(oldest);
                     this.cardToRequest.delete(oldest);
-                    if (oldReq !== undefined)
+                    if (oldReq !== undefined) {
                         this.requestToCard.delete(oldReq);
+                        this.requestProjects.delete(oldReq);
+                    }
                 }
                 this.cardToRequest.set(messageId, requestId);
                 this.requestToCard.set(requestId, messageId);
+                this.requestProjects.set(requestId, projectDir);
                 this.pendingSummaries.set(requestId, { summary, projectDir });
             }
             return messageId;
@@ -534,6 +660,10 @@ class FeishuBridge {
             return null;
         return this.cardToRequest.get(parentId) || null;
     }
+    /** 查某 requestId 卡片的归属项目空间（请求结束后仍可查，用于忙时排队路由） */
+    projectDirOf(requestId) {
+        return this.requestProjects.get(requestId) || null;
+    }
     /** 本实例当前待回复的请求数（用于多窗口判断） */
     pendingCount() {
         return this.pendingSummaries.size;