cursor-feedback 1.1.1 → 2.0.0

package/dist/extension.js

@@ -39,14 +39,17 @@ const vscode = __importStar(require("vscode"));
 const http = __importStar(require("http"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const i18n_1 = require("./i18n");
 let feedbackViewProvider = null;
-let pollingInterval = null;
+/** 规范化路径：统一分隔符、去尾斜杠、转小写，用于工作区匹配 */
+function normalizePath(p) {
+    return (p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+}
 function activate(context) {
-    console.log('Cursor Feedback extension is now active!');
     // 注册侧边栏 WebView（端口从 61927 开始自动扫描）
-    feedbackViewProvider = new FeedbackViewProvider(context.extensionUri, 61927);
-    context.subscriptions.push(vscode.window.registerWebviewViewProvider('cursorFeedback.feedbackView', feedbackViewProvider));
+    feedbackViewProvider = new FeedbackViewProvider(context.extensionUri, 61927, context.globalState);
+    context.subscriptions.push(vscode.window.registerWebviewViewProvider('cursorFeedback.feedbackView', feedbackViewProvider, { webviewOptions: { retainContextWhenHidden: true } }));
     // 注册命令：显示反馈面板
     context.subscriptions.push(vscode.commands.registerCommand('cursorFeedback.showPanel', () => {
         vscode.commands.executeCommand('cursorFeedback.feedbackView.focus');
@@ -55,14 +58,25 @@ function activate(context) {
     context.subscriptions.push(vscode.commands.registerCommand('cursorFeedback.startPolling', () => {
         if (feedbackViewProvider) {
             feedbackViewProvider.startPolling();
-            vscode.window.showInformationMessage(feedbackViewProvider.getMessage('startListening'));
         }
     }));
     // 注册命令：停止轮询
     context.subscriptions.push(vscode.commands.registerCommand('cursorFeedback.stopPolling', () => {
         if (feedbackViewProvider) {
             feedbackViewProvider.stopPolling();
-            vscode.window.showInformationMessage(feedbackViewProvider.getMessage('stopListening'));
+        }
+    }));
+    // 注册命令：带入编辑器选中代码到反馈输入框
+    context.subscriptions.push(vscode.commands.registerCommand('cursorFeedback.insertSelection', () => {
+        feedbackViewProvider?.insertSelectionToFeedback();
+    }));
+    // 缓存最近的活动编辑器（焦点在 feedback webview 时 activeTextEditor 会变 undefined）
+    if (vscode.window.activeTextEditor) {
+        feedbackViewProvider.setLastActiveEditor(vscode.window.activeTextEditor);
+    }
+    context.subscriptions.push(vscode.window.onDidChangeActiveTextEditor(editor => {
+        if (editor) {
+            feedbackViewProvider?.setLastActiveEditor(editor);
         }
     }));
     // 自动开始轮询
@@ -93,8 +107,7 @@ function getWorkspacePaths() {
 function isPathInWorkspace(targetPath) {
     const workspacePaths = getWorkspacePaths();
     // 规范化路径（去除末尾斜杠，统一分隔符，小写）
-    const normalize = (p) => p.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
-    const normalizedTarget = normalize(targetPath);
+    const normalizedTarget = normalizePath(targetPath);
     // 检查 targetPath 是否为空或默认值
     const isEmptyPath = !targetPath || targetPath === '.' || normalizedTarget === '' || normalizedTarget === '.';
     if (workspacePaths.length === 0) {
@@ -106,7 +119,7 @@ function isPathInWorkspace(targetPath) {
         return false;
     }
     for (const wsPath of workspacePaths) {
-        const normalizedWs = normalize(wsPath);
+        const normalizedWs = normalizePath(wsPath);
         // 精确匹配：只匹配完全相同的路径
         if (normalizedTarget === normalizedWs) {
             return true;
@@ -118,13 +131,29 @@ function isPathInWorkspace(targetPath) {
  * 侧边栏 WebView Provider
  */
 class FeedbackViewProvider {
-    constructor(_extensionUri, port) {
+    constructor(_extensionUri, port, _memento) {
         this._extensionUri = _extensionUri;
-        this._pollingInterval = null;
+        this._memento = _memento;
+        this._polling = false;
+        this._pollTimer = null;
+        this._pollDelay = 1000;
         this._currentRequest = null;
+        // webview 脚本是否就绪；插入上下文消息需等就绪后再发，否则 focus 唤起重建时会丢消息
+        this._webviewReady = false;
+        this._pendingInsert = null;
         this._activePort = null;
         this._portScanRange = 20; // 扫描端口范围
         this._seenRequestIds = new Set(); // 已处理过的请求 ID
+        // 超时续期开关（由侧边栏按钮切换，随轮询同步给 MCP server）
+        this._autoRetry = true;
+        // 飞书配置（持久化在 globalState；secret 会回显给 webview，前端用小眼睛切换明文/掩码）
+        this._feishuConfig = { appId: '', appSecret: '' };
+        // 飞书绑定状态（运行时，来自轮询 server；绑定本身由 server 端磁盘持久化、多进程共享）
+        this._feishuBound = false;
+        // 飞书通知开关（用户可关：即使配置了凭证也不推飞书）
+        this._feishuEnabled = true;
+        // Get 表情回执子开关（飞书通知子项；关掉后用户飞书回复不加 Get 表情、也不发文字兜底）
+        this._feishuAck = true;
         this._debugInfo = {
             portRange: '',
             workspacePath: '',
@@ -136,6 +165,12 @@ class FeedbackViewProvider {
         this._debugInfo.portRange = `${port}-${port + this._portScanRange - 1}`;
         this._i18n = (0, i18n_1.loadMessages)(this._extensionUri.fsPath);
         this._debugInfo.lastStatus = this._i18n.checkingConnection;
+        this._autoRetry = this._memento?.get('autoRetry', true) ?? true;
+        // 凭证真相源在 server 端磁盘；这里从 globalState 读上次的值仅作首屏占位，poll 一到即被 server 覆盖。
+        const fc = this._memento?.get('feishuConfig', {}) ?? {};
+        this._feishuConfig = { appId: fc.appId || '', appSecret: fc.appSecret || '' };
+        this._feishuEnabled = this._memento?.get('feishuEnabled', true) ?? true;
+        this._feishuAck = this._memento?.get('feishuAck', true) ?? true;
     }
     /**
      * 获取翻译消息
@@ -143,8 +178,19 @@ class FeedbackViewProvider {
     getMessage(key) {
         return this._i18n[key] || key;
     }
+    /** 翻译并替换 {占位符} 参数（用于带变量的状态文案） */
+    _t(key, params) {
+        let s = this._i18n[key] || key;
+        if (params) {
+            for (const k of Object.keys(params)) {
+                s = s.replace(`{${k}}`, String(params[k]));
+            }
+        }
+        return s;
+    }
     resolveWebviewView(webviewView, _context, _token) {
         this._view = webviewView;
+        this._webviewReady = false;
         webviewView.webview.options = {
             enableScripts: true,
             localResourceRoots: [this._extensionUri]
@@ -157,11 +203,17 @@ class FeedbackViewProvider {
                     await this._handleFeedbackSubmit(data.payload);
                     break;
                 case 'ready':
-                    console.log('Feedback WebView is ready');
+                    this._webviewReady = true;
+                    // 同步超时续期开关状态到 UI
+                    this._postAutoRetryState();
+                    this._postFeishuState();
                     // WebView 准备就绪后，检查是否有待处理的请求
-                    if (this._currentRequest) {
+                    // （插件通知关闭时保持静默，不显示缓存的请求）
+                    if (this._currentRequest && this._isPluginNotifyEnabled()) {
                         this._showFeedbackRequest(this._currentRequest);
                     }
+                    // 补发就绪前排队的「插入上下文」消息
+                    this._flushPendingInsert();
                     break;
                 case 'checkServer':
                     await this._checkServerHealth();
@@ -172,36 +224,78 @@ class FeedbackViewProvider {
                 case 'switchLanguage':
                     await this._handleSwitchLanguage();
                     break;
+                case 'toggleAutoRetry':
+                    await this._handleToggleAutoRetry();
+                    break;
+                case 'searchFiles':
+                    await this._handleSearchFiles();
+                    break;
+                case 'requestSelection':
+                    await this.insertSelectionToFeedback();
+                    break;
+                case 'saveFeishuConfig':
+                    await this._handleSaveFeishuConfig(data.payload);
+                    break;
+                case 'openFeishuGuide':
+                    await this._handleOpenFeishuGuide();
+                    break;
+                case 'toggleFeishuEnabled':
+                    await this._handleToggleFeishuEnabled(!!data.payload?.enabled);
+                    break;
+                case 'toggleSystemNotification':
+                    await this._handleToggleSystemNotification(!!data.payload?.enabled);
+                    break;
+                case 'toggleOsNotification':
+                    await this._handleToggleOsNotification(!!data.payload?.enabled);
+                    break;
+                case 'toggleFeishuAck':
+                    await this._handleToggleFeishuAck(!!data.payload?.enabled);
+                    break;
             }
         });
         // 当 view 变为可见时，检查当前请求
+        // （插件通知关闭时保持静默：即使用户从侧边栏切回面板也不显示缓存的请求）
         webviewView.onDidChangeVisibility(() => {
-            if (webviewView.visible && this._currentRequest) {
+            if (webviewView.visible && this._currentRequest && this._isPluginNotifyEnabled()) {
                 this._showFeedbackRequest(this._currentRequest);
             }
         });
     }
     /**
      * 开始轮询 MCP Server
+     *
+     * 自适应间隔：连上 server 时每秒轮询（兼作 server watchdog 心跳，必须 < 30s 空闲阈值）；
+     * 完全找不到 server 时指数退避到最多 5s，降低空闲 CPU / 电池开销。
+     * 一旦发现任意 server 立即恢复 1s。
      */
     startPolling() {
-        if (this._pollingInterval) {
+        if (this._polling) {
             return;
         }
-        console.log(`Starting polling MCP server from port ${this._basePort}`);
-        this._pollingInterval = setInterval(async () => {
+        this._polling = true;
+        this._pollDelay = 1000;
+        const loop = async () => {
+            if (!this._polling)
+                return;
             await this._pollForFeedbackRequest();
-        }, 1000); // 每秒检查一次
-        // 立即执行一次
-        this._pollForFeedbackRequest();
+            if (!this._polling)
+                return;
+            // 没连上任何 server → 退避；连上了 → 保持 1s 心跳
+            this._pollDelay = this._debugInfo.connectedPorts.length === 0
+                ? Math.min(this._pollDelay + 1000, 5000)
+                : 1000;
+            this._pollTimer = setTimeout(loop, this._pollDelay);
+        };
+        loop();
     }
     /**
      * 停止轮询
      */
     stopPolling() {
-        if (this._pollingInterval) {
-            clearInterval(this._pollingInterval);
-            this._pollingInterval = null;
+        this._polling = false;
+        if (this._pollTimer) {
+            clearTimeout(this._pollTimer);
+            this._pollTimer = null;
         }
     }
     /**
@@ -212,29 +306,34 @@ class FeedbackViewProvider {
         try {
             // 更新工作区路径
             const workspacePaths = getWorkspacePaths();
-            this._debugInfo.workspacePath = workspacePaths.length > 0 ? workspacePaths[0] : '(无工作区)';
+            this._debugInfo.workspacePath = workspacePaths.length > 0 ? workspacePaths[0] : this._t('statusNoWorkspace');
             const currentWorkspace = workspacePaths[0] || '';
-            const normalize = (p) => p.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
-            const normalizedCurrentWorkspace = normalize(currentWorkspace);
+            const normalizedCurrentWorkspace = normalizePath(currentWorkspace);
             // 如果有活跃端口，先尝试只轮询该端口
             if (this._activePort) {
                 const result = await this._checkPortForRequest(this._activePort);
                 // 检查是否仍然是我们的 Server
                 if (result.connected) {
-                    const serverOwner = result.ownerWorkspace ? normalize(result.ownerWorkspace) : '';
+                    const serverOwner = result.ownerWorkspace ? normalizePath(result.ownerWorkspace) : '';
                     const isMyServer = !serverOwner || serverOwner === normalizedCurrentWorkspace;
                     if (isMyServer) {
                         // 端口仍然有效，保持使用
                         this._debugInfo.connectedPorts = [this._activePort];
                         this._debugInfo.activePort = this._activePort;
                         if (result.request && !this._seenRequestIds.has(result.request.id)) {
-                            this._debugInfo.lastStatus = `监听端口 ${this._activePort}`;
+                            this._debugInfo.lastStatus = this._t('statusListening', { port: this._activePort });
                             this._handleNewRequest(result.request, this._activePort);
                             this._updateDebugInfo();
                             return;
                         }
+                        // 正在显示的请求被「飞书回复」结束 → 重置面板，避免提交到已消失的请求。
+                        // 仅当 server 明确标记该请求是被飞书 resolve 的才重置——超时续期时 request 也会短暂为 null，
+                        // 但 feishuResolvedId 不会命中，于是保持原有等待逻辑，不误重置、不丢用户草稿。
+                        if (this._currentRequest && result.feishuResolvedId === this._currentRequest.id) {
+                            this._handleExternalResolve();
+                        }
                         // 端口有效但无新请求，继续保持连接
-                        this._debugInfo.lastStatus = `监听端口 ${this._activePort}`;
+                        this._debugInfo.lastStatus = this._t('statusListening', { port: this._activePort });
                         this._updateDebugInfo();
                         return;
                     }
@@ -257,7 +356,7 @@ class FeedbackViewProvider {
                 if (!r.request || this._seenRequestIds.has(r.request.id)) {
                     return false;
                 }
-                const serverOwner = r.ownerWorkspace ? normalize(r.ownerWorkspace) : '';
+                const serverOwner = r.ownerWorkspace ? normalizePath(r.ownerWorkspace) : '';
                 return !serverOwner || serverOwner === normalizedCurrentWorkspace;
             }).sort((a, b) => b.request.timestamp - a.request.timestamp);
             // 处理最新的请求
@@ -265,7 +364,7 @@ class FeedbackViewProvider {
                 const newest = myRequests[0];
                 this._activePort = newest.port;
                 this._debugInfo.activePort = newest.port;
-                this._debugInfo.lastStatus = `找到请求 (端口 ${newest.port})`;
+                this._debugInfo.lastStatus = this._t('statusFound', { port: newest.port });
                 this._handleNewRequest(newest.request, newest.port);
                 this._updateDebugInfo();
                 return;
@@ -273,22 +372,22 @@ class FeedbackViewProvider {
             // 没有新请求，检查是否有当前请求
             if (this._currentRequest && this._activePort) {
                 this._debugInfo.activePort = this._activePort;
-                this._debugInfo.lastStatus = `监听端口 ${this._activePort}`;
+                this._debugInfo.lastStatus = this._t('statusListening', { port: this._activePort });
                 this._updateDebugInfo();
                 return;
             }
             // 没有任何请求
             this._debugInfo.activePort = null;
             if (this._debugInfo.connectedPorts.length === 0) {
-                this._debugInfo.lastStatus = '未找到 MCP Server';
+                this._debugInfo.lastStatus = this._t('statusNoServer');
             }
             else {
-                this._debugInfo.lastStatus = `已连接 ${this._debugInfo.connectedPorts.length} 个端口，等待请求`;
+                this._debugInfo.lastStatus = this._t('statusConnected', { count: this._debugInfo.connectedPorts.length });
             }
             this._updateDebugInfo();
         }
         catch (error) {
-            this._debugInfo.lastStatus = `轮询错误: ${error}`;
+            this._debugInfo.lastStatus = this._t('statusPollError', { error: String(error) });
             this._updateDebugInfo();
         }
     }
@@ -308,12 +407,14 @@ class FeedbackViewProvider {
             // 旧格式: FeedbackRequest | null
             let request;
             let ownerWorkspace = null;
-            let startTime = 0;
+            let feishuResolvedId = null;
             if (parsed && typeof parsed === 'object' && 'startTime' in parsed) {
                 // 新格式
                 request = parsed.request;
                 ownerWorkspace = parsed.ownerWorkspace;
-                startTime = parsed.startTime;
+                feishuResolvedId = parsed.feishuResolvedId ?? null;
+                this._maybeSyncFeishu(port, parsed.feishu);
+                this._maybeSyncAutoRetry(parsed.autoRetry);
             }
             else {
                 // 旧格式（兼容 npm 上的旧版本）
@@ -324,10 +425,10 @@ class FeedbackViewProvider {
                 const isMatch = isPathInWorkspace(request.projectDir);
                 if (!isMatch) {
                     // 请求不属于当前工作区，返回特殊标记
-                    return { connected: true, request: null, port, mismatch: true, ownerWorkspace, startTime };
+                    return { connected: true, request: null, port, mismatch: true, ownerWorkspace };
                 }
             }
-            return { connected: true, request, port, ownerWorkspace, startTime };
+            return { connected: true, request, port, ownerWorkspace, feishuResolvedId };
         }
         catch {
             return { connected: false, request: null, port };
@@ -344,7 +445,6 @@ class FeedbackViewProvider {
         // 判断是否为"新鲜"请求：创建后 10 秒内被发现
         const requestAge = Date.now() - request.timestamp;
         const isFreshRequest = requestAge < 10000; // 10秒内
-        console.log(`Feedback request on port ${port}:`, request.id, `age: ${requestAge}ms, isFresh: ${isFreshRequest}`);
         // 标记为已见过
         this._seenRequestIds.add(request.id);
         // 清理旧的请求 ID（保留最近 100 个）
@@ -355,15 +455,90 @@ class FeedbackViewProvider {
         if (!this._currentRequest || request.id !== this._currentRequest.id) {
             this._currentRequest = request;
             this._activePort = port;
-            // 显示请求内容
+            // 「插件通知」主开关（配置 key 历史原因仍叫 systemNotification）：关掉后本窗口完全静默——
+            // 不推送内容、不弹面板、不抢焦点、不发系统通知；连用户之后主动切回 / 打开面板也不显示
+            // （见 resolveWebviewView 里 ready 与 onDidChangeVisibility 的同款判断）。
+            // 请求仍记录在 _currentRequest，仅用于去重与外部渠道（飞书 / 超时）resolve 关联。
+            if (!this._isPluginNotifyEnabled()) {
+                return;
+            }
+            // 开启：推送内容并显示面板
             this._showFeedbackRequest(request);
-            // 只对新鲜请求自动聚焦和通知
+            // 只对新鲜请求做主动提醒（聚焦面板 + IDE 提示 + 失焦系统通知）
             if (isFreshRequest) {
                 vscode.commands.executeCommand('cursorFeedback.feedbackView.focus');
-                vscode.window.showInformationMessage(this._i18n.aiWaitingFeedback);
+                this._sendSystemNotification(request);
             }
         }
     }
+    /**
+     * 发送系统级通知（macOS / Windows / Linux）
+     *
+     * 场景：AI 运行较久时用户可能切去做别的事，IDE 内部的提示看不到，
+     * 等回来时反馈请求已超时。系统通知可以在 IDE 失焦时及时提醒用户回来。
+     *
+     * 仅在 IDE 窗口未聚焦时发送——窗口聚焦时 IDE 内部提示已足够，
+     * 避免每轮对话都弹系统通知造成打扰。
+     */
+    _sendSystemNotification(request) {
+        const config = vscode.workspace.getConfiguration('cursorFeedback');
+        if (!config.get('systemNotification', true)) {
+            return;
+        }
+        // 子开关「失焦时系统提示」：关掉后即使窗口失焦也不弹系统通知
+        if (!config.get('osNotification', true)) {
+            return;
+        }
+        if (vscode.window.state.focused) {
+            return;
+        }
+        const withSound = config.get('notificationSound', true);
+        const projectName = path.basename(request.projectDir || '')
+            || vscode.workspace.workspaceFolders?.[0]?.name
+            || '';
+        const title = projectName ? `Cursor Feedback · ${projectName}` : 'Cursor Feedback';
+        const body = this._i18n.aiWaitingFeedback;
+        try {
+            if (process.platform === 'darwin') {
+                // AppleScript 字符串转义（execFile 不经过 shell，无注入风险）
+                const esc = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+                let script = `display notification "${esc(body)}" with title "${esc(title)}"`;
+                if (withSound) {
+                    script += ' sound name "Glass"';
+                }
+                (0, child_process_1.execFile)('osascript', ['-e', script], () => { });
+            }
+            else if (process.platform === 'win32') {
+                // PowerShell 单引号字符串转义
+                const esc = (s) => s.replace(/'/g, "''");
+                // 使用 PowerShell 已注册的 AppId，未注册的 AppId 在 Win10/11 上会静默失败
+                const appId = '{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe';
+                const psScript = [
+                    '$null = [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime];',
+                    '$template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02);',
+                    "$texts = $template.GetElementsByTagName('text');",
+                    `$null = $texts.Item(0).AppendChild($template.CreateTextNode('${esc(title)}'));`,
+                    `$null = $texts.Item(1).AppendChild($template.CreateTextNode('${esc(body)}'));`,
+                    ...(withSound ? [] : [
+                        "$audio = $template.CreateElement('audio');",
+                        "$audio.SetAttribute('silent', 'true');",
+                        '$null = $template.DocumentElement.AppendChild($audio);'
+                    ]),
+                    '$toast = [Windows.UI.Notifications.ToastNotification]::new($template);',
+                    `[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('${esc(appId)}').Show($toast);`
+                ].join(' ');
+                (0, child_process_1.execFile)('powershell.exe', ['-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command', psScript], () => { });
+            }
+            else {
+                // Linux：依赖 notify-send（GNOME/KDE 等主流桌面均自带），缺失时静默忽略
+                (0, child_process_1.execFile)('notify-send', ['-u', 'normal', title, body], () => { });
+            }
+        }
+        catch (error) {
+            // 系统通知失败不影响主流程
+            console.error('Failed to send system notification:', error);
+        }
+    }
     /**
      * 检查服务器健康状态
      */
@@ -389,6 +564,15 @@ class FeedbackViewProvider {
             payload: { connected: false }
         });
     }
+    /**
+     * 「插件通知」主开关是否开启（配置 key 历史原因仍叫 systemNotification）。
+     * 关闭即本窗口完全静默：不主动推送，被动切回 / ready 时也不显示缓存的请求。
+     */
+    _isPluginNotifyEnabled() {
+        return vscode.workspace
+            .getConfiguration('cursorFeedback')
+            .get('systemNotification', true);
+    }
     /**
      * 显示反馈请求
      */
@@ -399,7 +583,7 @@ class FeedbackViewProvider {
                 type: 'showFeedbackRequest',
                 payload: {
                     requestId: request.id,
-                    summary: request.summary,
+                    summary: this._inlineLocalImages(request.summary),
                     projectDir: request.projectDir,
                     timeout: request.timeout,
                     timestamp: request.timestamp
@@ -417,6 +601,18 @@ class FeedbackViewProvider {
             });
         }
     }
+    /**
+     * 当前请求在 server 端被外部渠道结束（如飞书回复 / 超时）→ 重置面板，
+     * 防止用户对着已消失的请求提交，导致 "Request not found"。
+     */
+    _handleExternalResolve() {
+        if (!this._currentRequest)
+            return;
+        this._seenRequestIds.add(this._currentRequest.id);
+        this._currentRequest = null;
+        this._showWaitingState();
+        this._view?.webview.postMessage({ type: 'externalResolved' });
+    }
     /**
      * 更新调试信息到 WebView
      */
@@ -446,7 +642,6 @@ class FeedbackViewProvider {
             }));
             const result = JSON.parse(response);
             if (result.success) {
-                vscode.window.showInformationMessage(this._i18n.feedbackSubmitted);
                 this._currentRequest = null;
                 this._showWaitingState();
             }
@@ -476,6 +671,72 @@ class FeedbackViewProvider {
             });
         }
     }
+    setLastActiveEditor(editor) {
+        this._lastActiveEditor = editor;
+    }
+    /**
+     * 带入最近活动编辑器的选中代码（或整个文件）到反馈输入框
+     */
+    async insertSelectionToFeedback() {
+        const editor = this._lastActiveEditor || vscode.window.activeTextEditor;
+        await vscode.commands.executeCommand('cursorFeedback.feedbackView.focus');
+        if (!editor) {
+            this._postOrQueue({ type: 'insertContextEmpty' });
+            return;
+        }
+        const doc = editor.document;
+        const sel = editor.selection;
+        const filePath = doc.uri.fsPath;
+        if (sel && !sel.isEmpty) {
+            this._postOrQueue({
+                type: 'insertContext',
+                payload: {
+                    filePath,
+                    lang: doc.languageId,
+                    code: doc.getText(sel),
+                    startLine: sel.start.line + 1,
+                    endLine: sel.end.line + 1
+                }
+            });
+        }
+        else {
+            this._postOrQueue({
+                type: 'filesSelected',
+                payload: { paths: [filePath] }
+            });
+        }
+    }
+    /** 发送插入消息；若 webview 尚未就绪（focus 触发重建），先排队，待 ready 后补发 */
+    _postOrQueue(msg) {
+        this._pendingInsert = msg;
+        if (this._webviewReady) {
+            this._flushPendingInsert();
+        }
+    }
+    _flushPendingInsert() {
+        if (this._pendingInsert && this._view && this._webviewReady) {
+            this._view.webview.postMessage(this._pendingInsert);
+            this._pendingInsert = null;
+        }
+    }
+    /**
+     * 搜索工作区文件，回传给 webview 做 @ 引用选择
+     */
+    async _handleSearchFiles() {
+        try {
+            const uris = await vscode.workspace.findFiles('**/*', '**/{node_modules,.git,dist,out,build,.next,.cache,coverage}/**', 1000);
+            const files = uris.map(u => ({
+                path: u.fsPath,
+                name: u.path.split('/').pop() || u.fsPath,
+                rel: vscode.workspace.asRelativePath(u)
+            }));
+            files.sort((a, b) => a.rel.length - b.rel.length);
+            this._view?.webview.postMessage({ type: 'fileSearchResults', payload: { files } });
+        }
+        catch {
+            this._view?.webview.postMessage({ type: 'fileSearchResults', payload: { files: [] } });
+        }
+    }
     /**
      * 处理语言切换
      */
@@ -503,12 +764,188 @@ class FeedbackViewProvider {
             if (this._view) {
                 this._view.webview.html = this._getHtmlForWebview(this._view.webview);
             }
-            const effectiveLang = (0, i18n_1.getLanguage)();
-            vscode.window.showInformationMessage(effectiveLang === 'en'
-                ? 'Language changed to English'
-                : '语言已切换为简体中文');
         }
     }
+    /**
+     * 切换超时续期开关（AI 超时后是否继续等待用户）
+     */
+    async _handleToggleAutoRetry() {
+        this._autoRetry = !this._autoRetry;
+        await this._memento?.update('autoRetry', this._autoRetry);
+        this._postAutoRetryState();
+        this._broadcastAutoRetry();
+    }
+    /** 把续期开关 POST 给所有已连接 server（server 写同一份磁盘、全局一致、重启保留） */
+    _broadcastAutoRetry() {
+        const ports = new Set(this._debugInfo.connectedPorts || []);
+        if (this._activePort)
+            ports.add(this._activePort);
+        const body = JSON.stringify({ autoRetry: this._autoRetry });
+        for (const port of ports) {
+            this._httpPost(`http://127.0.0.1:${port}/api/settings/autoRetry`, body).catch(() => { });
+        }
+    }
+    /**
+     * 把超时续期开关状态推给 WebView
+     */
+    _postAutoRetryState() {
+        this._view?.webview.postMessage({
+            type: 'autoRetryState',
+            payload: { enabled: this._autoRetry }
+        });
+    }
+    /** 从 server poll 回读续期开关并回显到 UI（server 为真相源，单向同步，避免多窗口拉锯） */
+    _maybeSyncAutoRetry(v) {
+        if (typeof v !== 'boolean' || v === this._autoRetry)
+            return;
+        this._autoRetry = v;
+        this._memento?.update('autoRetry', v);
+        this._postAutoRetryState();
+    }
+    /**
+     * 把飞书配置状态推给 WebView（含 secret 明文，前端用小眼睛切换显示/隐藏）
+     */
+    _postFeishuState() {
+        const { appId, appSecret } = this._feishuConfig;
+        const cfg = vscode.workspace.getConfiguration('cursorFeedback');
+        const systemNotification = cfg.get('systemNotification', true);
+        const osNotification = cfg.get('osNotification', true);
+        this._view?.webview.postMessage({
+            type: 'feishuState',
+            payload: {
+                appId,
+                appSecret,
+                hasSecret: !!appSecret,
+                configured: !!(appId && appSecret),
+                bound: this._feishuBound,
+                feishuEnabled: this._feishuEnabled,
+                feishuAck: this._feishuAck,
+                systemNotification: !!systemNotification,
+                osNotification: !!osNotification
+            }
+        });
+    }
+    /**
+     * 处理保存飞书配置（来自 webview）
+     * - 所见即生效：appId/secret 直接用输入框的值，删空就是删空（半填 = 凭证不全 = server 关闭）。
+     * - appId 变化：本地先解绑（真相仍以 server 磁盘 / poll 回读为准）。
+     */
+    async _handleSaveFeishuConfig(payload) {
+        const appId = (payload?.appId || '').trim();
+        const appSecret = (payload?.appSecret || '').trim();
+        if (appId !== this._feishuConfig.appId)
+            this._feishuBound = false;
+        this._feishuConfig = { appId, appSecret };
+        // 占位缓存（真相在 server 磁盘，poll 会回读覆盖）
+        await this._memento?.update('feishuConfig', this._feishuConfig);
+        // 下发给所有端口：server 写磁盘（全局真相源）+ configure；清空则下发空 → server 关闭 / 清空。
+        this._broadcastFeishuConfig();
+        this._postFeishuState();
+    }
+    /**
+     * 轮询时把 server 的飞书状态同步到本地用于回显。
+     * 凭证真相源在 server 端磁盘（跨窗口共享）：插件只读不回写，从根上消除多窗口「A 删 B 又补回」的拉锯。
+     * 同步凭证 / 开关 / Get 表情 / 绑定，有变化才刷新面板。
+     */
+    _maybeSyncFeishu(_port, feishuStatus) {
+        if (!feishuStatus)
+            return;
+        const appId = feishuStatus.appId || '';
+        const appSecret = feishuStatus.appSecret || '';
+        const enabled = feishuStatus.enabled !== false;
+        const ack = feishuStatus.ackReaction !== false;
+        const bound = !!feishuStatus.boundChatId;
+        let changed = false;
+        if (appId !== this._feishuConfig.appId || appSecret !== this._feishuConfig.appSecret) {
+            this._feishuConfig = { appId, appSecret };
+            // 落一份到 globalState 作首屏占位缓存（真相仍以 server 为准）
+            this._memento?.update('feishuConfig', this._feishuConfig);
+            changed = true;
+        }
+        if (enabled !== this._feishuEnabled) {
+            this._feishuEnabled = enabled;
+            changed = true;
+        }
+        if (ack !== this._feishuAck) {
+            this._feishuAck = ack;
+            changed = true;
+        }
+        if (bound !== this._feishuBound) {
+            this._feishuBound = bound;
+            changed = true;
+        }
+        if (changed)
+            this._postFeishuState();
+    }
+    /** 把当前飞书配置 POST 给所有已连接的 server（server 端写同一份磁盘、全局一致；清空即下发空以关闭） */
+    _broadcastFeishuConfig() {
+        const ports = new Set(this._debugInfo.connectedPorts || []);
+        if (this._activePort)
+            ports.add(this._activePort);
+        const { appId, appSecret } = this._feishuConfig;
+        const body = JSON.stringify({
+            appId,
+            appSecret,
+            enabled: this._feishuEnabled,
+            ackReaction: this._feishuAck,
+        });
+        for (const port of ports) {
+            this._httpPost(`http://127.0.0.1:${port}/api/feishu/config`, body).catch(() => { });
+        }
+    }
+    /**
+     * 打开「如何配置飞书机器人」指引
+     */
+    async _handleOpenFeishuGuide() {
+        const guideUri = vscode.Uri.joinPath(this._extensionUri, 'docs', 'feishu-setup.md');
+        try {
+            await vscode.commands.executeCommand('markdown.showPreview', guideUri);
+        }
+        catch {
+            try {
+                await vscode.env.openExternal(guideUri);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    /**
+     * 切换飞书通知开关（关了即使已配置也不推飞书；长连接仍保留以便绑定/回复）
+     */
+    async _handleToggleFeishuEnabled(enabled) {
+        this._feishuEnabled = enabled;
+        await this._memento?.update('feishuEnabled', enabled);
+        this._broadcastFeishuConfig();
+        this._postFeishuState();
+    }
+    /**
+     * 切换系统通知开关（写入 VSCode 配置，_sendSystemNotification 会读取）
+     */
+    async _handleToggleSystemNotification(enabled) {
+        await vscode.workspace
+            .getConfiguration('cursorFeedback')
+            .update('systemNotification', enabled, vscode.ConfigurationTarget.Global);
+        this._postFeishuState();
+    }
+    /**
+     * 切换「失焦时系统提示」子开关（插件通知的子项，写入 VSCode 配置）
+     */
+    async _handleToggleOsNotification(enabled) {
+        await vscode.workspace
+            .getConfiguration('cursorFeedback')
+            .update('osNotification', enabled, vscode.ConfigurationTarget.Global);
+        this._postFeishuState();
+    }
+    /**
+     * 切换「Get 表情回执」子开关（飞书通知的子项；透传到 server 端 feishu bridge）
+     */
+    async _handleToggleFeishuAck(enabled) {
+        this._feishuAck = enabled;
+        await this._memento?.update('feishuAck', enabled);
+        this._broadcastFeishuConfig();
+        this._postFeishuState();
+    }
     /**
      * HTTP GET 请求
      */
@@ -557,29 +994,85 @@ class FeedbackViewProvider {
             req.end();
         });
     }
+    /**
+     * 把 summary 里的本地图片路径内联成 base64 data:，
+     * 这样 webview 无需 file:// 访问权限即可显示 AI 发来的本地图片。
+     * 网络图（http/https）和已有的 data:/blob: 不处理，交给 CSP 放行。
+     */
+    _inlineLocalImages(md) {
+        if (!md)
+            return md;
+        return md.replace(/!\[([^\]]*)\]\(\s*([^)\s]+)(\s+"[^"]*")?\s*\)/g, (full, alt, src, title) => {
+            try {
+                let p = String(src).trim().replace(/^["']|["']$/g, '');
+                if (/^(https?:|data:|blob:)/i.test(p))
+                    return full;
+                if (p.startsWith('file://'))
+                    p = decodeURIComponent(p.replace(/^file:\/\//, ''));
+                if (!path.isAbsolute(p) || !fs.existsSync(p))
+                    return full;
+                const mime = this._imageMime(p);
+                if (!mime)
+                    return full;
+                const b64 = fs.readFileSync(p).toString('base64');
+                return `![${alt}](data:${mime};base64,${b64}${title || ''})`;
+            }
+            catch {
+                return full;
+            }
+        });
+    }
+    _imageMime(p) {
+        switch (path.extname(p).toLowerCase()) {
+            case '.png': return 'image/png';
+            case '.jpg':
+            case '.jpeg': return 'image/jpeg';
+            case '.gif': return 'image/gif';
+            case '.webp': return 'image/webp';
+            case '.svg': return 'image/svg+xml';
+            case '.bmp': return 'image/bmp';
+            default: return null;
+        }
+    }
     _getHtmlForWebview(webview) {
         // 获取资源文件的 URI
         const markedJsUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, 'resources', 'vendor', 'marked.min.js'));
+        const highlightJsUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, 'resources', 'vendor', 'highlight.min.js'));
         const stylesCssUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, 'dist', 'webview', 'styles.css'));
         const scriptJsUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, 'dist', 'webview', 'script.js'));
         // 读取 HTML 模板
         const htmlTemplatePath = path.join(this._extensionUri.fsPath, 'dist', 'webview', 'index.html');
         let htmlTemplate = fs.readFileSync(htmlTemplatePath, 'utf-8');
-        // CSP 策略
-        const csp = `default-src 'none'; style-src ${webview.cspSource}; script-src 'unsafe-inline' ${webview.cspSource}; img-src data:;`;
+        // CSP 策略：放宽 img-src 以支持 AI 在 summary 里发来的网络图片 / vscode 资源 / base64
+        const csp = `default-src 'none'; style-src ${webview.cspSource}; script-src 'unsafe-inline' ${webview.cspSource}; img-src ${webview.cspSource} https: data: blob:;`;
         // 获取语言设置
         const language = (0, i18n_1.getLanguage)();
         const langCode = language === 'zh-TW' ? 'zh-TW' : (language === 'en' ? 'en' : 'zh-CN');
+        // 按平台解析快捷键占位符（mac vs win/linux），未知占位符保持原样
+        const isMac = process.platform === 'darwin';
+        const placeholders = {
+            shortcut: isMac ? '⇧⌘\'' : 'Ctrl+Shift+\'',
+            ctrlEnter: isMac ? '⌘Enter' : 'Ctrl+Enter',
+            shiftEnter: isMac ? '⇧Enter' : 'Shift+Enter',
+        };
+        const i18nResolved = {};
+        for (const k of Object.keys(this._i18n)) {
+            const v = this._i18n[k];
+            i18nResolved[k] = typeof v === 'string'
+                ? v.replace(/\{(\w+)\}/g, (m, name) => placeholders[name] ?? m)
+                : v;
+        }
         // 替换占位符
         htmlTemplate = htmlTemplate
             .replace(/\{\{CSP\}\}/g, csp)
             .replace(/\{\{LANG\}\}/g, langCode)
             .replace(/\{\{MARKED_JS_URI\}\}/g, markedJsUri.toString())
+            .replace(/\{\{HIGHLIGHT_JS_URI\}\}/g, highlightJsUri.toString())
             .replace(/\{\{STYLES_CSS_URI\}\}/g, stylesCssUri.toString())
             .replace(/\{\{SCRIPT_JS_URI\}\}/g, scriptJsUri.toString())
-            .replace(/\{\{I18N_JSON\}\}/g, JSON.stringify(this._i18n))
+            .replace(/\{\{I18N_JSON\}\}/g, JSON.stringify(i18nResolved))
             .replace(/\{\{i18n\.(\w+)\}\}/g, (_, key) => {
-            return this._i18n[key] || key;
+            return i18nResolved[key] || key;
         });
         return htmlTemplate;
     }