vite-plugin-opencode-assistant 1.0.0

package/dist/client.js

@@ -0,0 +1,1549 @@
+"use strict";
+/**
+ * @fileoverview OpenCode 挂件客户端脚本
+ * @description 用于在浏览器中显示 OpenCode AI 助手挂件
+ */
+(function () {
+    'use strict';
+    /** @type {string} 初始化标记 */
+    const INIT_MARKER = '__OPENCODE_INITIALIZED__';
+    /** @type {string} 选中元素存储键 */
+    const SELECTED_ELEMENTS_KEY = '__opencode_selected_elements__';
+    /** @type {number} 服务器同步间隔（毫秒） */
+    const SERVER_SYNC_INTERVAL = 2000;
+    /** @type {number} 检查 Vue Inspector 间隔（毫秒） */
+    const INSPECTOR_CHECK_INTERVAL = 500;
+    /** @type {number} 自动打开延迟（毫秒） */
+    const AUTO_OPEN_DELAY = 1000;
+    /** @type {number} 通知显示时间（毫秒） */
+    const NOTIFICATION_DURATION = 3000;
+    /**
+     * @typedef {Object} HotkeyConfig
+     * @property {boolean} ctrl - 是否需要 Ctrl/Meta 键
+     * @property {boolean} shift - 是否需要 Shift 键
+     * @property {boolean} alt - 是否需要 Alt 键
+     * @property {string} key - 主键
+     */
+    /**
+     * @typedef {Object} SelectedElement
+     * @property {string|null} filePath - 文件路径
+     * @property {number|null} line - 行号
+     * @property {number|null} column - 列号
+     * @property {string} innerText - 元素内部文本
+     * @property {string} description - 元素描述（标签名+选择器）
+     */
+    /**
+     * @typedef {Object} WidgetConfig
+     * @property {string} webUrl - Web 服务 URL
+     * @property {string} position - 挂件位置
+     * @property {string} theme - 主题模式
+     * @property {boolean} open - 是否自动打开
+     * @property {string} sessionUrl - 会话 URL
+     * @property {boolean} lazy - 是否懒加载
+     * @property {string} hotkey - 快捷键配置
+     */
+    /**
+     * 初始化 OpenCode 挂件
+     * @param {WidgetConfig} config - 挂件配置
+     */
+    function initOpenCodeWidget(config) {
+        if (window[INIT_MARKER])
+            return;
+        window[INIT_MARKER] = true;
+        const { webUrl, position, theme, open, sessionUrl, lazy, hotkey, cwd } = config;
+        /** @type {string} 当前页面 URL */
+        let currentPageUrl = '';
+        /** @type {string} 当前页面标题 */
+        let currentPageTitle = '';
+        /** @type {boolean} 服务是否已启动 */
+        let servicesStarted = !lazy;
+        /** @type {boolean} 挂件是否打开 */
+        let isOpen = false;
+        /**
+         * 解析快捷键字符串
+         * @param {string} hotkeyStr - 快捷键字符串，如 'ctrl+k'
+         * @returns {HotkeyConfig} 快捷键配置
+         */
+        function parseHotkey(hotkeyStr) {
+            if (!hotkeyStr)
+                return { ctrl: true, shift: false, alt: false, key: 'k' };
+            const parts = hotkeyStr.toLowerCase().split('+');
+            const key = parts.pop();
+            return {
+                ctrl: parts.includes('ctrl') || parts.includes('cmd') || parts.includes('meta'),
+                shift: parts.includes('shift'),
+                alt: parts.includes('alt'),
+                key: key || 'k'
+            };
+        }
+        /** @type {HotkeyConfig} 主快捷键配置 */
+        const mainHotkey = parseHotkey(hotkey);
+        /**
+         * 检查键盘事件是否匹配快捷键
+         * @param {KeyboardEvent} e - 键盘事件
+         * @param {HotkeyConfig} hotkeyConfig - 快捷键配置
+         * @returns {boolean} 是否匹配
+         */
+        function matchHotkey(e, hotkeyConfig) {
+            const ctrlMatch = hotkeyConfig.ctrl ? (e.ctrlKey || e.metaKey) : !(e.ctrlKey || e.metaKey);
+            const shiftMatch = hotkeyConfig.shift ? e.shiftKey : !e.shiftKey;
+            const altMatch = hotkeyConfig.alt ? e.altKey : !e.altKey;
+            const keyMatch = e.key.toLowerCase() === hotkeyConfig.key.toLowerCase();
+            return ctrlMatch && shiftMatch && altMatch && keyMatch;
+        }
+        /**
+         * 从 sessionStorage 加载选中的元素
+         * @returns {SelectedElement[]} 选中的元素列表
+         */
+        function loadSelectedElements() {
+            try {
+                const stored = sessionStorage.getItem(SELECTED_ELEMENTS_KEY);
+                if (stored) {
+                    return JSON.parse(stored);
+                }
+            }
+            catch (e) {
+                // 忽略错误
+            }
+            return [];
+        }
+        /**
+         * 保存选中的元素到 sessionStorage
+         * @param {SelectedElement[]} elements - 选中的元素列表
+         */
+        function saveSelectedElements(elements) {
+            try {
+                sessionStorage.setItem(SELECTED_ELEMENTS_KEY, JSON.stringify(elements));
+            }
+            catch (e) {
+                // 忽略错误
+            }
+        }
+        /** @type {SelectedElement[]} 选中的元素列表 */
+        let selectedElements = loadSelectedElements();
+        /**
+         * 确保服务已启动
+         * @returns {Promise<boolean>} 是否成功启动
+         */
+        async function ensureServicesStarted() {
+            if (servicesStarted)
+                return true;
+            try {
+                const res = await fetch('/__opencode_start__');
+                const data = await res.json();
+                if (data.success) {
+                    servicesStarted = true;
+                    if (data.sessionUrl && iframe) {
+                        iframe.src = data.sessionUrl;
+                    }
+                    return true;
+                }
+            }
+            catch (e) {
+                console.error('[OpenCode Widget] Failed to start services:', e);
+            }
+            return false;
+        }
+        /**
+         * 更新页面上下文
+         * @param {boolean} [force=false] - 是否强制更新
+         */
+        function updateContext(force = false) {
+            if (!servicesStarted)
+                return;
+            const newUrl = window.location.href;
+            const newTitle = document.title;
+            if (force || newUrl !== currentPageUrl || newTitle !== currentPageTitle) {
+                currentPageUrl = newUrl;
+                currentPageTitle = newTitle;
+                fetch('/__opencode_context__', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ url: newUrl, title: newTitle, selectedElements })
+                }).catch(() => { });
+            }
+        }
+        // 监听路由变化
+        const originalPushState = history.pushState;
+        const originalReplaceState = history.replaceState;
+        history.pushState = function (...args) {
+            originalPushState.apply(this, args);
+            setTimeout(updateContext, 0);
+        };
+        history.replaceState = function (...args) {
+            originalReplaceState.apply(this, args);
+            setTimeout(updateContext, 0);
+        };
+        window.addEventListener('popstate', () => setTimeout(updateContext, 0));
+        window.addEventListener('hashchange', () => setTimeout(updateContext, 0));
+        // 监听标题变化
+        const titleObserver = new MutationObserver(() => {
+            if (document.title !== currentPageTitle) {
+                updateContext();
+            }
+        });
+        if (document.head) {
+            titleObserver.observe(document.head, { childList: true, subtree: true });
+        }
+        if (servicesStarted) {
+            updateContext(true);
+        }
+        /** @type {string} iframe URL */
+        const iframeUrl = sessionUrl || webUrl;
+        // 创建样式
+        const style = document.createElement('style');
+        style.textContent = buildWidgetStyles();
+        document.head.appendChild(style);
+        // 创建容器
+        const container = document.createElement('div');
+        container.className = `opencode-widget ${position}`;
+        // 创建按钮
+        const button = document.createElement('button');
+        button.className = 'opencode-button';
+        button.innerHTML = `
+      <svg t="1775402599580" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns=" http://www.w3.org/2000/svg " p-id="5390" xmlns:xlink=" http://www.w3.org/1999/xlink " width="200" height="200"><path d="M512 981.33H85.34c-15.85 0-30.38-8.77-37.77-22.81a42.624 42.624 0 0 1 2.6-44.02L135 791.08C75.25 710.5 42.67 612.6 42.67 512 42.67 253.21 253.21 42.67 512 42.67S981.34 253.21 981.34 512 770.8 981.33 512 981.33zM166.44 896H512c211.73 0 384-172.27 384-384S723.73 128 512 128 128 300.27 128 512c0 91.29 32.83 179.9 92.46 249.46 12.58 14.69 13.73 36 2.77 51.94L166.44 896z" fill="white" p-id="5391"></path><path d="M384 448m-64 0a64 64 0 1 0 128 0 64 64 0 1 0-128 0Z" fill="white" p-id="5392"></path><path d="M640 448m-64 0a64 64 0 1 0 128 0 64 64 0 1 0-128 0Z" fill="white" p-id="5393"></path></svg>
+    `;
+        button.setAttribute('aria-label', 'Open AI Assistant');
+        // 创建聊天面板
+        const chat = document.createElement('div');
+        chat.className = 'opencode-chat';
+        // 创建会话列表
+        const sessionList = document.createElement('div');
+        sessionList.className = 'opencode-session-list collapsed';
+        // 创建折叠按钮
+        const toggleBtn = document.createElement('button');
+        toggleBtn.className = 'opencode-session-toggle';
+        toggleBtn.innerHTML = `
+      <svg viewBox="0 0 24 24" width="16" height="16" xmlns="http://www.w3.org/2000/svg">
+        <path d="M4 6h16M4 12h16M4 18h16" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+      </svg>
+    `;
+        toggleBtn.title = '展开会话列表';
+        // 创建会话列表头部
+        const sessionListHeader = document.createElement('div');
+        sessionListHeader.className = 'opencode-session-list-header';
+        sessionListHeader.innerHTML = `
+      <span>会话列表</span>
+      <button class="opencode-new-session-btn" title="新建会话">+</button>
+    `;
+        // 创建会话列表内容
+        const sessionListContent = document.createElement('div');
+        sessionListContent.className = 'opencode-session-list-content';
+        sessionList.appendChild(toggleBtn);
+        sessionList.appendChild(sessionListHeader);
+        sessionList.appendChild(sessionListContent);
+        // 折叠/展开会话列表
+        let isSessionListCollapsed = true;
+        function toggleSessionList() {
+            isSessionListCollapsed = !isSessionListCollapsed;
+            sessionList.classList.toggle('collapsed', isSessionListCollapsed);
+            toggleBtn.title = isSessionListCollapsed ? '展开会话列表' : '折叠会话列表';
+        }
+        toggleBtn.addEventListener('click', toggleSessionList);
+        // 创建 iframe 容器
+        const iframeContainer = document.createElement('div');
+        iframeContainer.className = 'opencode-iframe-container';
+        // 创建加载指示器
+        const loadingOverlay = document.createElement('div');
+        loadingOverlay.className = 'opencode-loading-overlay';
+        loadingOverlay.innerHTML = `
+      <div class="opencode-loading-spinner"></div>
+      <div class="opencode-loading-text">加载中...</div>
+    `;
+        // 创建 iframe
+        const iframe = document.createElement('iframe');
+        iframe.className = 'opencode-iframe';
+        iframe.src = servicesStarted ? iframeUrl : 'about:blank';
+        iframe.allow = 'clipboard-write; clipboard-read';
+        iframe.referrerPolicy = 'origin';
+        iframe.onload = function () {
+            if (servicesStarted) {
+                updateContext();
+                loadSessions();
+            }
+            hideLoading();
+        };
+        iframeContainer.appendChild(loadingOverlay);
+        iframeContainer.appendChild(iframe);
+        // 创建右侧工具栏
+        const rightToolbar = document.createElement('div');
+        rightToolbar.className = `opencode-right-toolbar${selectedElements.length === 0 ? ' collapsed' : ''}`;
+        // 创建元素选择按钮
+        const selectButton = document.createElement('button');
+        selectButton.className = 'opencode-select-btn';
+        selectButton.innerHTML = `
+      <svg viewBox="0 0 1024 1024" width="18" height="18" xmlns="http://www.w3.org/2000/svg">
+        <path fill="currentColor" d="M512 896a384 384 0 1 0 0-768 384 384 0 0 0 0 768m0 64a448 448 0 1 1 0-896 448 448 0 0 1 0 896"></path><path fill="currentColor" d="M512 96a32 32 0 0 1 32 32v192a32 32 0 0 1-64 0V128a32 32 0 0 1 32-32m0 576a32 32 0 0 1 32 32v192a32 32 0 1 1-64 0V704a32 32 0 0 1 32-32M96 512a32 32 0 0 1 32-32h192a32 32 0 0 1 0 64H128a32 32 0 0 1-32-32m576 0a32 32 0 0 1 32-32h192a32 32 0 1 1 0 64H704a32 32 0 0 1-32-32"></path>
+      </svg>
+    `;
+        selectButton.title = '选择页面元素';
+        // 创建已选节点容器
+        const selectedNodesContainer = document.createElement('div');
+        selectedNodesContainer.className = 'opencode-selected-nodes';
+        rightToolbar.appendChild(selectButton);
+        rightToolbar.appendChild(selectedNodesContainer);
+        // 创建选择模式常驻提示（固定到页面顶部）
+        const selectModeHint = document.createElement('div');
+        selectModeHint.className = 'opencode-select-mode-hint';
+        selectModeHint.innerHTML = `
+      <span>🎯 选择模式已开启 - 点击元素进行选择</span>
+      <span class="opencode-hint-shortcut">按 ESC 退出</span>
+    `;
+        // 创建已选节点气泡容器（气泡按钮上方）
+        const selectedBubbles = document.createElement('div');
+        selectedBubbles.className = 'opencode-selected-bubbles';
+        chat.appendChild(sessionList);
+        chat.appendChild(iframeContainer);
+        chat.appendChild(rightToolbar);
+        container.appendChild(button);
+        container.appendChild(selectedBubbles);
+        container.appendChild(chat);
+        document.body.appendChild(container);
+        document.body.appendChild(selectModeHint);
+        if (selectedElements.length > 0) {
+            renderSelectedNodes();
+        }
+        /** @type {Array} 会话列表 */
+        let sessions = [];
+        /** @type {string|null} 当前会话 ID */
+        let currentSessionId = null;
+        /**
+         * 从 URL 中提取会话 ID
+         */
+        function extractSessionId(url) {
+            if (!url)
+                return null;
+            const match = url.match(/\/session\/([^/?]+)/);
+            return match ? match[1] : null;
+        }
+        // 从初始 URL 中提取会话 ID
+        currentSessionId = extractSessionId(sessionUrl);
+        /**
+         * 显示加载状态
+         */
+        function showLoading() {
+            loadingOverlay.classList.add('visible');
+        }
+        /**
+         * 隐藏加载状态
+         */
+        function hideLoading() {
+            loadingOverlay.classList.remove('visible');
+        }
+        /**
+         * 加载会话列表
+         */
+        async function loadSessions() {
+            try {
+                const response = await fetch('/__opencode_sessions__');
+                sessions = await response.json();
+                renderSessionList();
+            }
+            catch (e) {
+                console.error('Failed to load sessions:', e);
+            }
+        }
+        /**
+         * 渲染会话列表
+         */
+        function renderSessionList() {
+            sessionListContent.innerHTML = '';
+            const currentProjectSessions = sessions.filter(session => session.directory === cwd);
+            currentProjectSessions.forEach(session => {
+                const item = document.createElement('div');
+                item.className = 'opencode-session-item';
+                if (session.id === currentSessionId) {
+                    item.classList.add('active');
+                }
+                const header = document.createElement('div');
+                header.className = 'opencode-session-header';
+                const title = document.createElement('div');
+                title.className = 'opencode-session-title';
+                title.textContent = session.title || '新会话';
+                const deleteBtn = document.createElement('button');
+                deleteBtn.className = 'opencode-session-delete-btn';
+                deleteBtn.innerHTML = '×';
+                deleteBtn.title = '删除会话';
+                deleteBtn.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    confirmDeleteSession(session);
+                });
+                header.appendChild(title);
+                header.appendChild(deleteBtn);
+                const meta = document.createElement('div');
+                meta.className = 'opencode-session-meta';
+                const date = new Date(session.time.updated);
+                meta.textContent = date.toLocaleDateString() + ' ' + date.toLocaleTimeString();
+                item.appendChild(header);
+                item.appendChild(meta);
+                item.addEventListener('click', () => {
+                    switchSession(session);
+                });
+                sessionListContent.appendChild(item);
+            });
+        }
+        /**
+         * 切换会话
+         */
+        function switchSession(session) {
+            if (session.id === currentSessionId) {
+                return;
+            }
+            currentSessionId = session.id;
+            const encodedDir = btoa(cwd);
+            const baseUrl = iframeUrl.split('/').slice(0, 3).join('/');
+            showLoading();
+            iframe.src = `${baseUrl}/${encodedDir}/session/${session.id}`;
+            renderSessionList();
+        }
+        /**
+         * 创建新会话
+         */
+        async function createNewSession() {
+            try {
+                const response = await fetch('/__opencode_sessions__', {
+                    method: 'POST'
+                });
+                const newSession = await response.json();
+                sessions.unshift(newSession);
+                switchSession(newSession);
+            }
+            catch (e) {
+                console.error('Failed to create session:', e);
+                showNotification('创建会话失败');
+            }
+        }
+        /**
+         * 确认删除会话
+         */
+        function confirmDeleteSession(session) {
+            const confirmed = confirm(`确定要删除会话 "${session.title || '新会话'}" 吗？`);
+            if (confirmed) {
+                deleteSession(session);
+            }
+        }
+        /**
+         * 删除会话
+         */
+        async function deleteSession(session) {
+            try {
+                const response = await fetch(`/__opencode_sessions__?id=${session.id}`, {
+                    method: 'DELETE'
+                });
+                if (!response.ok) {
+                    throw new Error('Delete failed');
+                }
+                sessions = sessions.filter(s => s.id !== session.id);
+                if (session.id === currentSessionId) {
+                    const remainingSessions = sessions.filter(s => s.directory === cwd);
+                    if (remainingSessions.length > 0) {
+                        switchSession(remainingSessions[0]);
+                    }
+                    else {
+                        currentSessionId = null;
+                        iframe.src = 'about:blank';
+                    }
+                }
+                renderSessionList();
+                showNotification('会话已删除');
+            }
+            catch (e) {
+                console.error('Failed to delete session:', e);
+                showNotification('删除会话失败');
+            }
+        }
+        // 绑定新建会话按钮
+        sessionListHeader.querySelector('.opencode-new-session-btn').addEventListener('click', createNewSession);
+        /**
+         * 应用主题
+         */
+        function applyTheme() {
+            if (theme === 'auto') {
+                const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+                container.classList.toggle('opencode-dark', prefersDark);
+            }
+            else {
+                container.classList.toggle('opencode-dark', theme === 'dark');
+            }
+        }
+        applyTheme();
+        if (theme === 'auto') {
+            window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', applyTheme);
+        }
+        /**
+         * 切换挂件显示状态
+         */
+        async function toggle() {
+            if (lazy && !servicesStarted) {
+                button.classList.add('loading');
+                const started = await ensureServicesStarted();
+                button.classList.remove('loading');
+                if (!started) {
+                    showNotification('服务启动失败，请检查控制台');
+                    return;
+                }
+            }
+            isOpen = !isOpen;
+            chat.classList.toggle('open', isOpen);
+            button.classList.toggle('active', isOpen);
+            if (isOpen) {
+                updateContext();
+            }
+        }
+        button.addEventListener('click', toggle);
+        document.addEventListener('keydown', (e) => {
+            if (matchHotkey(e, mainHotkey)) {
+                e.preventDefault();
+                toggle();
+            }
+        });
+        if (open && servicesStarted) {
+            setTimeout(() => {
+                toggle();
+            }, AUTO_OPEN_DELAY);
+        }
+        /**
+         * 显示通知
+         * @param {string} message - 通知消息
+         */
+        function showNotification(message) {
+            const notification = document.createElement('div');
+            notification.className = 'opencode-notification';
+            notification.textContent = message;
+            chat.appendChild(notification);
+            setTimeout(() => {
+                notification.remove();
+            }, NOTIFICATION_DURATION);
+        }
+        /**
+         * 添加选中元素
+         * @param {SelectedElement} elementInfo - 元素信息
+         */
+        function addElement(elementInfo) {
+            const key = elementInfo.filePath && elementInfo.line
+                ? `${elementInfo.filePath}:${elementInfo.line}`
+                : null;
+            const exists = key && selectedElements.some(el => {
+                const elKey = el.filePath && el.line ? `${el.filePath}:${el.line}` : null;
+                return elKey === key;
+            });
+            if (!exists) {
+                selectedElements.push(elementInfo);
+                saveSelectedElements(selectedElements);
+                renderSelectedNodes();
+                if (isSelectMode) {
+                    renderSelectedBubbles();
+                }
+                showNotification(`已选中元素 (${selectedElements.length}个)`);
+            }
+            else {
+                showNotification('该元素已选中');
+            }
+        }
+        /**
+         * 移除选中元素
+         * @param {number} index - 元素索引
+         */
+        function removeElement(index) {
+            selectedElements.splice(index, 1);
+            saveSelectedElements(selectedElements);
+            renderSelectedNodes();
+            updateToolbarState();
+            sendSelectedElements();
+        }
+        /**
+         * 清除所有选中元素
+         */
+        function clearAllElements() {
+            selectedElements = [];
+            saveSelectedElements(selectedElements);
+            renderSelectedNodes();
+            updateToolbarState();
+            sendSelectedElements();
+            showNotification('已清除所有选中元素');
+        }
+        /**
+         * 更新工具栏状态
+         */
+        function updateToolbarState() {
+            if (selectedElements.length > 0) {
+                rightToolbar.classList.remove('collapsed');
+            }
+            else {
+                rightToolbar.classList.add('collapsed');
+            }
+        }
+        /** @type {boolean} 是否处于元素选择模式 */
+        let isSelectMode = false;
+        /**
+         * 切换元素选择模式
+         */
+        function toggleSelectMode() {
+            const inspector = window.__VUE_INSPECTOR__;
+            if (!inspector) {
+                showNotification('Vue Inspector 未加载，无法使用元素选择功能');
+                return;
+            }
+            isSelectMode = !isSelectMode;
+            selectButton.classList.toggle('active', isSelectMode);
+            selectModeHint.classList.toggle('visible', isSelectMode);
+            selectedBubbles.classList.toggle('visible', isSelectMode);
+            if (isSelectMode) {
+                chat.style.display = 'none';
+                inspector.enable();
+                renderSelectedBubbles();
+            }
+            else {
+                chat.style.display = '';
+                inspector.disable();
+            }
+        }
+        /**
+         * 退出选择模式
+         */
+        function exitSelectMode() {
+            if (!isSelectMode)
+                return;
+            const inspector = window.__VUE_INSPECTOR__;
+            if (inspector) {
+                inspector.disable();
+            }
+            isSelectMode = false;
+            selectButton.classList.remove('active');
+            selectModeHint.classList.remove('visible');
+            selectedBubbles.classList.remove('visible');
+            chat.style.display = '';
+        }
+        // ESC 键退出选择模式
+        document.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape' && isSelectMode) {
+                exitSelectMode();
+            }
+        });
+        /**
+         * 渲染已选节点气泡
+         */
+        function renderSelectedBubbles() {
+            selectedBubbles.innerHTML = '';
+            if (selectedElements.length === 0) {
+                selectedBubbles.innerHTML = '<div class="opencode-bubble-empty">暂无选中元素</div>';
+                return;
+            }
+            selectedElements.forEach((element, index) => {
+                const bubble = document.createElement('div');
+                bubble.className = 'opencode-selected-bubble';
+                const description = element.description || '未知元素';
+                const fileName = element.filePath ? element.filePath.split('/').pop() : '';
+                const lineInfo = element.line ? `:${element.line}` : '';
+                bubble.innerHTML = `
+          <span class="opencode-bubble-text">${description}</span>
+          ${fileName ? `<span class="opencode-bubble-file">${fileName}${lineInfo}</span>` : ''}
+          <button class="opencode-bubble-remove" data-index="${index}">×</button>
+        `;
+                bubble.querySelector('.opencode-bubble-remove').addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    removeElement(index);
+                    renderSelectedBubbles();
+                });
+                selectedBubbles.appendChild(bubble);
+            });
+        }
+        function renderSelectedNodes() {
+            selectedNodesContainer.innerHTML = '';
+            if (selectedElements.length === 0) {
+                rightToolbar.classList.add('collapsed');
+            }
+            else {
+                rightToolbar.classList.remove('collapsed');
+            }
+            selectedElements.forEach((element, index) => {
+                const node = document.createElement('div');
+                node.className = 'opencode-selected-node';
+                const description = element.description || '未知元素';
+                const textPreview = element.innerText ? element.innerText.substring(0, 30) : '';
+                const fileName = element.filePath ? element.filePath.split('/').pop() : '未知文件';
+                const lineInfo = element.line ? `:${element.line}` : '';
+                node.innerHTML = `
+          <div class="opencode-node-content">
+            <span class="opencode-node-text">${description}</span>
+            <span class="opencode-node-file">${textPreview ? textPreview + ' · ' : ''}${fileName}${lineInfo}</span>
+          </div>
+          <button class="opencode-node-remove" data-index="${index}">×</button>
+        `;
+                node.querySelector('.opencode-node-remove').addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    removeElement(index);
+                });
+                selectedNodesContainer.appendChild(node);
+            });
+        }
+        // 绑定选择按钮点击事件
+        selectButton.addEventListener('click', toggleSelectMode);
+        /**
+         * 发送选中元素到服务器
+         */
+        function sendSelectedElements() {
+            if (!servicesStarted)
+                return;
+            fetch('/__opencode_context__', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    url: currentPageUrl,
+                    title: currentPageTitle,
+                    selectedElements: selectedElements
+                })
+            }).catch(() => { });
+        }
+        /**
+         * 与服务器同步选中元素
+         */
+        function syncWithServer() {
+            if (!servicesStarted)
+                return;
+            fetch('/__opencode_context__')
+                .then(res => res.json())
+                .then(data => {
+                if (data.selectedElements && data.selectedElements.length === 0 && selectedElements.length > 0) {
+                    selectedElements = [];
+                    saveSelectedElements(selectedElements);
+                    renderSelectedNodes();
+                }
+            })
+                .catch(() => { });
+        }
+        setInterval(syncWithServer, SERVER_SYNC_INTERVAL);
+        /**
+         * 截断字符串
+         * @param {string} str - 原字符串
+         * @param {number} maxLength - 最大长度
+         * @returns {string} 截断后的字符串
+         */
+        function truncate(str, maxLength) {
+            if (!str)
+                return '';
+            return str.length > maxLength ? str.substring(0, maxLength) + '...' : str;
+        }
+        /**
+         * 获取元素的直接文本内容
+         * @param {Element} element - DOM 元素
+         * @returns {string} 直接文本内容
+         */
+        function getDirectText(element) {
+            let text = '';
+            for (const child of element.childNodes) {
+                if (child.nodeType === Node.TEXT_NODE) {
+                    text += child.textContent || '';
+                }
+            }
+            return text.trim();
+        }
+        /**
+         * 获取元素描述信息
+         * @param {Element} element - DOM 元素
+         * @returns {string} 元素描述
+         */
+        function getElementDescription(element) {
+            const tag = element.tagName.toLowerCase();
+            const parts = [tag];
+            const id = element.id;
+            if (id)
+                parts.push(`#${id}`);
+            const className = element.className && typeof element.className === 'string'
+                ? element.className.trim().split(/\s+/).filter(Boolean).slice(0, 2).join('.')
+                : '';
+            if (className)
+                parts.push(`.${className}`);
+            const name = element.getAttribute('name');
+            if (name)
+                parts.push(`[name="${name}"]`);
+            const placeholder = element.getAttribute('placeholder');
+            if (placeholder)
+                parts.push(`[placeholder="${placeholder.substring(0, 20)}"]`);
+            const src = element.getAttribute('src');
+            if (src)
+                parts.push(`[src]`);
+            const href = element.getAttribute('href');
+            if (href && href !== '#')
+                parts.push(`[href]`);
+            return parts.join('');
+        }
+        /**
+         * 设置 Vue Inspector 钩子
+         */
+        function setupInspectorHook() {
+            if (window.__VUE_INSPECTOR__) {
+                const inspector = window.__VUE_INSPECTOR__;
+                const originalHandleClick = inspector.handleClick.bind(inspector);
+                inspector.handleClick = function (e) {
+                    if (isSelectMode) {
+                        const { targetNode, params } = inspector.getTargetNode(e);
+                        if (targetNode && params) {
+                            const innerText = getDirectText(targetNode);
+                            const description = getElementDescription(targetNode);
+                            const elementInfo = {
+                                filePath: params.file,
+                                line: params.line,
+                                column: params.column,
+                                innerText: truncate(innerText, 200),
+                                description
+                            };
+                            addElement(elementInfo);
+                            sendSelectedElements();
+                        }
+                        return;
+                    }
+                    return originalHandleClick.call(inspector, e);
+                };
+            }
+        }
+        if (window.__VUE_INSPECTOR__) {
+            setupInspectorHook();
+        }
+        else {
+            const checkInspector = setInterval(() => {
+                if (window.__VUE_INSPECTOR__) {
+                    setupInspectorHook();
+                    clearInterval(checkInspector);
+                }
+            }, INSPECTOR_CHECK_INTERVAL);
+        }
+        // 导出全局 API
+        window.OpenCodeWidget = {
+            open: () => { if (!isOpen)
+                toggle(); },
+            close: () => { if (isOpen)
+                toggle(); },
+            toggle,
+            showNotification,
+            updateContext,
+        };
+    }
+    /**
+     * 构建挂件样式
+     * @returns {string} CSS 样式字符串
+     */
+    function buildWidgetStyles() {
+        return `
+      .opencode-widget {
+        position: fixed;
+        z-index: 999999;
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      }
+
+      .opencode-widget.bottom-right {
+        bottom: 20px;
+        right: 20px;
+      }
+
+      .opencode-widget.bottom-left {
+        bottom: 20px;
+        left: 20px;
+      }
+
+      .opencode-widget.top-right {
+        top: 20px;
+        right: 20px;
+      }
+
+      .opencode-widget.top-left {
+        top: 20px;
+        left: 20px;
+      }
+
+      .opencode-button {
+        width: 60px;
+        height: 60px;
+        border-radius: 50%;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border: none;
+        cursor: pointer;
+        box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
+        transition: all 0.3s ease;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: white;
+        padding: 0;
+      }
+
+      .opencode-button:hover {
+        transform: scale(1.1);
+        box-shadow: 0 6px 20px rgba(102, 126, 234, 0.6);
+        background: linear-gradient(135deg, #764ba2 0%, #667eea 100%);
+      }
+
+      .opencode-button.active {
+        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+        box-shadow: 0 6px 20px rgba(240, 147, 251, 0.4);
+        transform: rotate(180deg);
+      }
+
+      .opencode-button.loading {
+        animation: pulse 1s infinite;
+      }
+
+      @keyframes pulse {
+        0%, 100% { opacity: 1; }
+        50% { opacity: 0.5; }
+      }
+
+      .opencode-chat {
+        position: absolute;
+        width: 700px;
+        height: 80vh;
+        background: white;
+        border-radius: 16px;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.12);
+        overflow: hidden;
+        opacity: 0;
+        visibility: hidden;
+        transform: translateY(20px) scale(0.95);
+        transition: all 0.3s ease;
+        display: flex;
+      }
+
+      .opencode-widget.bottom-right .opencode-chat {
+        bottom: 80px;
+        right: 0;
+      }
+
+      .opencode-widget.bottom-left .opencode-chat {
+        bottom: 80px;
+        left: 0;
+      }
+
+      .opencode-widget.top-right .opencode-chat {
+        top: 80px;
+        right: 0;
+      }
+
+      .opencode-widget.top-left .opencode-chat {
+        top: 80px;
+        left: 0;
+      }
+
+      .opencode-chat.open {
+        opacity: 1;
+        visibility: visible;
+        transform: translateY(0) scale(1);
+      }
+
+      .opencode-session-list {
+        width: 240px;
+        background: #f8f9fa;
+        border-right: 1px solid #e5e7eb;
+        display: flex;
+        flex-direction: column;
+        flex-shrink: 0;
+        transition: width 0.2s ease;
+      }
+
+      .opencode-session-list.collapsed {
+        width: 40px;
+      }
+
+      .opencode-session-toggle {
+        width: 100%;
+        height: 40px;
+        border: none;
+        background: transparent;
+        color: #6b7280;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: all 0.2s;
+        border-bottom: 1px solid #e5e7eb;
+      }
+
+      .opencode-session-toggle:hover {
+        background: #e5e7eb;
+        color: #374151;
+      }
+
+      .opencode-session-list.collapsed .opencode-session-list-header,
+      .opencode-session-list.collapsed .opencode-session-list-content {
+        display: none;
+      }
+
+      .opencode-session-list-header {
+        padding: 16px;
+        border-bottom: 1px solid #e5e7eb;
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        font-weight: 600;
+        font-size: 14px;
+        color: #374151;
+      }
+
+      .opencode-new-session-btn {
+        width: 28px;
+        height: 28px;
+        border-radius: 6px;
+        border: none;
+        background: #3b82f6;
+        color: white;
+        font-size: 18px;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: all 0.2s;
+      }
+
+      .opencode-new-session-btn:hover {
+        background: #2563eb;
+        transform: scale(1.05);
+      }
+
+      .opencode-session-list-content {
+        flex: 1;
+        overflow-y: auto;
+        padding: 8px;
+      }
+
+      .opencode-session-item {
+        padding: 12px;
+        border-radius: 8px;
+        cursor: pointer;
+        transition: all 0.2s;
+        margin-bottom: 4px;
+      }
+
+      .opencode-session-item:hover {
+        background: #e5e7eb;
+      }
+
+      .opencode-session-item.active {
+        background: #3b82f6;
+        color: white;
+      }
+
+      .opencode-session-title {
+        font-size: 14px;
+        font-weight: 500;
+        margin-bottom: 4px;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .opencode-session-meta {
+        font-size: 12px;
+        opacity: 0.6;
+      }
+
+      .opencode-session-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 4px;
+      }
+
+      .opencode-session-delete-btn {
+        width: 20px;
+        height: 20px;
+        border-radius: 4px;
+        border: none;
+        background: transparent;
+        color: #6b7280;
+        font-size: 16px;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: all 0.2s;
+        opacity: 0;
+        flex-shrink: 0;
+      }
+
+      .opencode-session-item:hover .opencode-session-delete-btn {
+        opacity: 1;
+      }
+
+      .opencode-session-delete-btn:hover {
+        background: #ef4444;
+        color: white;
+      }
+
+      .opencode-session-item.active .opencode-session-delete-btn {
+        color: rgba(255, 255, 255, 0.7);
+      }
+
+      .opencode-session-item.active .opencode-session-delete-btn:hover {
+        background: rgba(255, 255, 255, 0.2);
+        color: white;
+      }
+
+      .opencode-iframe-container {
+        flex: 1;
+        position: relative;
+        overflow: hidden;
+        display: flex;
+        flex-direction: column;
+      }
+
+      .opencode-loading-overlay {
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background: rgba(255, 255, 255, 0.9);
+        display: none;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        z-index: 10;
+        transition: opacity 0.3s ease;
+      }
+
+      .opencode-loading-overlay.visible {
+        display: flex;
+      }
+
+      .opencode-loading-spinner {
+        width: 40px;
+        height: 40px;
+        border: 3px solid #e5e7eb;
+        border-top-color: #3b82f6;
+        border-radius: 50%;
+        animation: spin 0.8s linear infinite;
+      }
+
+      @keyframes spin {
+        to { transform: rotate(360deg); }
+      }
+
+      .opencode-loading-text {
+        margin-top: 12px;
+        font-size: 14px;
+        color: #6b7280;
+      }
+
+      .opencode-iframe {
+        position: absolute;
+        top: -136px;
+        width: 100%;
+        height: calc(100% + 136px);
+        border: none;
+        transition: opacity 0.3s ease;
+      }
+
+      .opencode-dark .opencode-chat {
+        background: #1a1a1a;
+      }
+
+      .opencode-dark .opencode-session-list {
+        background: #111827;
+        border-right-color: #374151;
+      }
+
+      .opencode-dark .opencode-session-toggle {
+        color: #9ca3af;
+        border-bottom-color: #374151;
+      }
+
+      .opencode-dark .opencode-session-toggle:hover {
+        background: #374151;
+        color: #f3f4f6;
+      }
+
+      .opencode-dark .opencode-session-list-header {
+        border-bottom-color: #374151;
+        color: #f3f4f6;
+      }
+
+      .opencode-dark .opencode-session-item:hover {
+        background: #374151;
+      }
+
+      .opencode-dark .opencode-session-item.active {
+        background: #3b82f6;
+      }
+
+      .opencode-dark .opencode-loading-overlay {
+        background: rgba(26, 26, 26, 0.9);
+      }
+
+      .opencode-dark .opencode-loading-spinner {
+        border-color: #374151;
+        border-top-color: #3b82f6;
+      }
+
+      .opencode-dark .opencode-loading-text {
+        color: #9ca3af;
+      }
+
+      .opencode-right-toolbar {
+        width: 140px;
+        background: #f8f9fa;
+        border-left: 1px solid #e5e7eb;
+        display: flex;
+        flex-direction: column;
+        flex-shrink: 0;
+        transition: width 0.2s ease;
+      }
+
+      .opencode-right-toolbar.collapsed {
+        width: 40px;
+      }
+
+      .opencode-right-toolbar.collapsed .opencode-selected-nodes {
+        display: none;
+      }
+
+      .opencode-select-btn {
+        width: 100%;
+        height: 44px;
+        border: none;
+        background: transparent;
+        color: #6b7280;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 8px;
+        transition: all 0.2s;
+        border-bottom: 1px solid #e5e7eb;
+        font-size: 13px;
+        font-weight: 500;
+      }
+
+      .opencode-select-btn:hover {
+        background: #e5e7eb;
+        color: #374151;
+      }
+
+      .opencode-select-btn.active {
+        background: #3b82f6;
+        color: white;
+      }
+
+      .opencode-selected-nodes {
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        padding: 8px;
+        gap: 6px;
+        overflow-y: auto;
+        overflow-x: hidden;
+      }
+
+      .opencode-selected-nodes:empty::before {
+        content: '暂无选中元素';
+        color: #9ca3af;
+        font-size: 12px;
+        text-align: center;
+        padding: 20px 10px;
+      }
+
+      .opencode-selected-node {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        padding: 8px 10px;
+        background: white;
+        border: 1px solid #e5e7eb;
+        border-radius: 6px;
+        font-size: 12px;
+        transition: all 0.2s;
+      }
+
+      .opencode-selected-node:hover {
+        border-color: #3b82f6;
+        box-shadow: 0 2px 4px rgba(59, 130, 246, 0.1);
+      }
+
+      .opencode-node-content {
+        flex: 1;
+        min-width: 0;
+        display: flex;
+        flex-direction: column;
+        gap: 2px;
+      }
+
+      .opencode-node-text {
+        color: #374151;
+        font-weight: 500;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .opencode-node-file {
+        color: #9ca3af;
+        font-size: 11px;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .opencode-node-remove {
+        width: 18px;
+        height: 18px;
+        border-radius: 4px;
+        border: none;
+        background: transparent;
+        color: #9ca3af;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 14px;
+        transition: all 0.2s;
+        flex-shrink: 0;
+      }
+
+      .opencode-node-remove:hover {
+        background: #ef4444;
+        color: white;
+      }
+
+      .opencode-dark .opencode-right-toolbar {
+        background: #111827;
+        border-left-color: #374151;
+      }
+
+      .opencode-dark .opencode-select-btn {
+        color: #9ca3af;
+        border-bottom-color: #374151;
+      }
+
+      .opencode-dark .opencode-select-btn:hover {
+        background: #374151;
+        color: #f3f4f6;
+      }
+
+      .opencode-dark .opencode-selected-nodes:empty::before {
+        color: #6b7280;
+      }
+
+      .opencode-dark .opencode-selected-node {
+        background: #1f2937;
+        border-color: #374151;
+      }
+
+      .opencode-dark .opencode-selected-node:hover {
+        border-color: #3b82f6;
+      }
+
+      .opencode-dark .opencode-node-text {
+        color: #f3f4f6;
+      }
+
+      .opencode-dark .opencode-node-file {
+        color: #6b7280;
+      }
+
+      .opencode-dark .opencode-node-remove {
+        color: #6b7280;
+      }
+
+      .opencode-dark .opencode-node-remove:hover {
+        background: #ef4444;
+        color: white;
+      }
+
+      .opencode-dark .opencode-button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        box-shadow: 0 4px 15px rgba(102, 126, 234, 0.5);
+      }
+
+      .opencode-notification {
+        position: absolute;
+        top: 20px;
+        left: 50%;
+        transform: translateX(-50%);
+        padding: 12px 20px;
+        background: #10b981;
+        color: white;
+        border-radius: 8px;
+        font-size: 14px;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+        animation: slideDown 0.3s ease;
+        z-index: 10;
+      }
+
+      @keyframes slideDown {
+        from {
+          transform: translateX(-50%) translateY(-100%);
+          opacity: 0;
+        }
+        to {
+          transform: translateX(-50%) translateY(0);
+          opacity: 1;
+        }
+      }
+
+      .opencode-select-mode-hint {
+        position: fixed;
+        top: 20px;
+        left: 50%;
+        transform: translateX(-50%);
+        padding: 10px 16px;
+        background: #3b82f6;
+        color: white;
+        border-radius: 8px;
+        font-size: 13px;
+        box-shadow: 0 4px 12px rgba(59, 130, 246, 0.3);
+        z-index: 9999999;
+        display: none;
+        align-items: center;
+        gap: 12px;
+      }
+
+      .opencode-select-mode-hint.visible {
+        display: flex;
+        animation: slideDown 0.3s ease;
+      }
+
+      .opencode-hint-shortcut {
+        padding: 2px 6px;
+        background: rgba(255, 255, 255, 0.2);
+        border-radius: 4px;
+        font-size: 12px;
+      }
+
+      .opencode-selected-bubbles {
+        position: absolute;
+        bottom: 70px;
+        right: 0;
+        display: none;
+        flex-direction: column;
+        gap: 6px;
+        max-width: 220px;
+        max-height: 300px;
+        overflow-y: auto;
+      }
+
+      .opencode-selected-bubbles.visible {
+        display: flex;
+      }
+
+      .opencode-selected-bubble {
+        display: flex;
+        flex-direction: column;
+        gap: 2px;
+        padding: 8px 10px;
+        background: white;
+        border: 1px solid #e5e7eb;
+        border-radius: 8px;
+        font-size: 12px;
+        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+        position: relative;
+      }
+
+      .opencode-bubble-text {
+        color: #374151;
+        font-weight: 500;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .opencode-bubble-file {
+        color: #9ca3af;
+        font-size: 11px;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .opencode-bubble-remove {
+        position: absolute;
+        top: 4px;
+        right: 4px;
+        width: 16px;
+        height: 16px;
+        border-radius: 50%;
+        border: none;
+        background: transparent;
+        color: #9ca3af;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 12px;
+        transition: all 0.2s;
+      }
+
+      .opencode-bubble-remove:hover {
+        background: #ef4444;
+        color: white;
+      }
+
+      .opencode-bubble-empty {
+        padding: 8px 12px;
+        background: white;
+        border: 1px dashed #d1d5db;
+        border-radius: 8px;
+        color: #9ca3af;
+        font-size: 12px;
+        text-align: center;
+      }
+
+      .opencode-dark .opencode-selected-bubble {
+        background: #1f2937;
+        border-color: #374151;
+      }
+
+      .opencode-dark .opencode-bubble-text {
+        color: #f3f4f6;
+      }
+
+      .opencode-dark .opencode-bubble-file {
+        color: #6b7280;
+      }
+
+      .opencode-dark .opencode-bubble-remove {
+        color: #6b7280;
+      }
+
+      .opencode-dark .opencode-bubble-empty {
+        background: #1f2937;
+        border-color: #374151;
+        color: #6b7280;
+      }
+
+      @media (max-width: 768px) {
+        .opencode-chat {
+          width: calc(100vw - 40px);
+          height: calc(100vh - 120px);
+        }
+      }
+    `;
+    }
+    /**
+     * 自动初始化挂件
+     */
+    function autoInit() {
+        const script = document.currentScript || document.querySelector('script[data-opencode-config]');
+        if (script) {
+            const configBase64 = script.getAttribute('data-opencode-config');
+            if (configBase64) {
+                try {
+                    const config = JSON.parse(atob(configBase64));
+                    if (document.readyState === 'loading') {
+                        document.addEventListener('DOMContentLoaded', function () {
+                            initOpenCodeWidget(config);
+                        });
+                    }
+                    else {
+                        initOpenCodeWidget(config);
+                    }
+                }
+                catch (e) {
+                    console.error('[OpenCode Widget] Failed to parse config:', e);
+                }
+            }
+        }
+    }
+    // 导出全局初始化函数
+    window.initOpenCodeWidget = initOpenCodeWidget;
+    // 自动初始化
+    autoInit();
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.js"],"names":[],"mappings":"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","sourcesContent":["/**\n * @fileoverview OpenCode 挂件客户端脚本\n * @description 用于在浏览器中显示 OpenCode AI 助手挂件\n */\n\n(function() {\n  'use strict'\n\n  /** @type {string} 初始化标记 */\n  const INIT_MARKER = '__OPENCODE_INITIALIZED__'\n\n  /** @type {string} 选中元素存储键 */\n  const SELECTED_ELEMENTS_KEY = '__opencode_selected_elements__'\n\n  /** @type {number} 服务器同步间隔（毫秒） */\n  const SERVER_SYNC_INTERVAL = 2000\n\n  /** @type {number} 检查 Vue Inspector 间隔（毫秒） */\n  const INSPECTOR_CHECK_INTERVAL = 500\n\n  /** @type {number} 自动打开延迟（毫秒） */\n  const AUTO_OPEN_DELAY = 1000\n\n  /** @type {number} 通知显示时间（毫秒） */\n  const NOTIFICATION_DURATION = 3000\n\n  /**\n   * @typedef {Object} HotkeyConfig\n   * @property {boolean} ctrl - 是否需要 Ctrl/Meta 键\n   * @property {boolean} shift - 是否需要 Shift 键\n   * @property {boolean} alt - 是否需要 Alt 键\n   * @property {string} key - 主键\n   */\n\n  /**\n   * @typedef {Object} SelectedElement\n   * @property {string|null} filePath - 文件路径\n   * @property {number|null} line - 行号\n   * @property {number|null} column - 列号\n   * @property {string} innerText - 元素内部文本\n   * @property {string} description - 元素描述（标签名+选择器）\n   */\n\n  /**\n   * @typedef {Object} WidgetConfig\n   * @property {string} webUrl - Web 服务 URL\n   * @property {string} position - 挂件位置\n   * @property {string} theme - 主题模式\n   * @property {boolean} open - 是否自动打开\n   * @property {string} sessionUrl - 会话 URL\n   * @property {boolean} lazy - 是否懒加载\n   * @property {string} hotkey - 快捷键配置\n   */\n\n  /**\n   * 初始化 OpenCode 挂件\n   * @param {WidgetConfig} config - 挂件配置\n   */\n  function initOpenCodeWidget(config) {\n    if (window[INIT_MARKER]) return\n    window[INIT_MARKER] = true\n\n    const { webUrl, position, theme, open, sessionUrl, lazy, hotkey, cwd } = config\n\n    /** @type {string} 当前页面 URL */\n    let currentPageUrl = ''\n\n    /** @type {string} 当前页面标题 */\n    let currentPageTitle = ''\n\n    /** @type {boolean} 服务是否已启动 */\n    let servicesStarted = !lazy\n\n    /** @type {boolean} 挂件是否打开 */\n    let isOpen = false\n\n    /**\n     * 解析快捷键字符串\n     * @param {string} hotkeyStr - 快捷键字符串，如 'ctrl+k'\n     * @returns {HotkeyConfig} 快捷键配置\n     */\n    function parseHotkey(hotkeyStr) {\n      if (!hotkeyStr) return { ctrl: true, shift: false, alt: false, key: 'k' }\n\n      const parts = hotkeyStr.toLowerCase().split('+')\n      const key = parts.pop()\n\n      return {\n        ctrl: parts.includes('ctrl') || parts.includes('cmd') || parts.includes('meta'),\n        shift: parts.includes('shift'),\n        alt: parts.includes('alt'),\n        key: key || 'k'\n      }\n    }\n\n    /** @type {HotkeyConfig} 主快捷键配置 */\n    const mainHotkey = parseHotkey(hotkey)\n\n    /**\n     * 检查键盘事件是否匹配快捷键\n     * @param {KeyboardEvent} e - 键盘事件\n     * @param {HotkeyConfig} hotkeyConfig - 快捷键配置\n     * @returns {boolean} 是否匹配\n     */\n    function matchHotkey(e, hotkeyConfig) {\n      const ctrlMatch = hotkeyConfig.ctrl ? (e.ctrlKey || e.metaKey) : !(e.ctrlKey || e.metaKey)\n      const shiftMatch = hotkeyConfig.shift ? e.shiftKey : !e.shiftKey\n      const altMatch = hotkeyConfig.alt ? e.altKey : !e.altKey\n      const keyMatch = e.key.toLowerCase() === hotkeyConfig.key.toLowerCase()\n\n      return ctrlMatch && shiftMatch && altMatch && keyMatch\n    }\n\n    /**\n     * 从 sessionStorage 加载选中的元素\n     * @returns {SelectedElement[]} 选中的元素列表\n     */\n    function loadSelectedElements() {\n      try {\n        const stored = sessionStorage.getItem(SELECTED_ELEMENTS_KEY)\n        if (stored) {\n          return JSON.parse(stored)\n        }\n      } catch (e) {\n        // 忽略错误\n      }\n      return []\n    }\n\n    /**\n     * 保存选中的元素到 sessionStorage\n     * @param {SelectedElement[]} elements - 选中的元素列表\n     */\n    function saveSelectedElements(elements) {\n      try {\n        sessionStorage.setItem(SELECTED_ELEMENTS_KEY, JSON.stringify(elements))\n      } catch (e) {\n        // 忽略错误\n      }\n    }\n\n    /** @type {SelectedElement[]} 选中的元素列表 */\n    let selectedElements = loadSelectedElements()\n\n    /**\n     * 确保服务已启动\n     * @returns {Promise<boolean>} 是否成功启动\n     */\n    async function ensureServicesStarted() {\n      if (servicesStarted) return true\n\n      try {\n        const res = await fetch('/__opencode_start__')\n        const data = await res.json()\n        if (data.success) {\n          servicesStarted = true\n          if (data.sessionUrl && iframe) {\n            iframe.src = data.sessionUrl\n          }\n          return true\n        }\n      } catch (e) {\n        console.error('[OpenCode Widget] Failed to start services:', e)\n      }\n      return false\n    }\n\n    /**\n     * 更新页面上下文\n     * @param {boolean} [force=false] - 是否强制更新\n     */\n    function updateContext(force = false) {\n      if (!servicesStarted) return\n\n      const newUrl = window.location.href\n      const newTitle = document.title\n\n      if (force || newUrl !== currentPageUrl || newTitle !== currentPageTitle) {\n        currentPageUrl = newUrl\n        currentPageTitle = newTitle\n\n        fetch('/__opencode_context__', {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ url: newUrl, title: newTitle, selectedElements })\n        }).catch(() => {})\n      }\n    }\n\n    // 监听路由变化\n    const originalPushState = history.pushState\n    const originalReplaceState = history.replaceState\n\n    history.pushState = function(...args) {\n      originalPushState.apply(this, args)\n      setTimeout(updateContext, 0)\n    }\n\n    history.replaceState = function(...args) {\n      originalReplaceState.apply(this, args)\n      setTimeout(updateContext, 0)\n    }\n\n    window.addEventListener('popstate', () => setTimeout(updateContext, 0))\n    window.addEventListener('hashchange', () => setTimeout(updateContext, 0))\n\n    // 监听标题变化\n    const titleObserver = new MutationObserver(() => {\n      if (document.title !== currentPageTitle) {\n        updateContext()\n      }\n    })\n\n    if (document.head) {\n      titleObserver.observe(document.head, { childList: true, subtree: true })\n    }\n\n    if (servicesStarted) {\n      updateContext(true)\n    }\n\n    /** @type {string} iframe URL */\n    const iframeUrl = sessionUrl || webUrl\n\n    // 创建样式\n    const style = document.createElement('style')\n    style.textContent = buildWidgetStyles()\n    document.head.appendChild(style)\n\n    // 创建容器\n    const container = document.createElement('div')\n    container.className = `opencode-widget ${position}`\n\n    // 创建按钮\n    const button = document.createElement('button')\n    button.className = 'opencode-button'\n    button.innerHTML = `\n      <svg t=\"1775402599580\" class=\"icon\" viewBox=\"0 0 1024 1024\" version=\"1.1\" xmlns=\" http://www.w3.org/2000/svg \" p-id=\"5390\" xmlns:xlink=\" http://www.w3.org/1999/xlink \" width=\"200\" height=\"200\"><path d=\"M512 981.33H85.34c-15.85 0-30.38-8.77-37.77-22.81a42.624 42.624 0 0 1 2.6-44.02L135 791.08C75.25 710.5 42.67 612.6 42.67 512 42.67 253.21 253.21 42.67 512 42.67S981.34 253.21 981.34 512 770.8 981.33 512 981.33zM166.44 896H512c211.73 0 384-172.27 384-384S723.73 128 512 128 128 300.27 128 512c0 91.29 32.83 179.9 92.46 249.46 12.58 14.69 13.73 36 2.77 51.94L166.44 896z\" fill=\"white\" p-id=\"5391\"></path><path d=\"M384 448m-64 0a64 64 0 1 0 128 0 64 64 0 1 0-128 0Z\" fill=\"white\" p-id=\"5392\"></path><path d=\"M640 448m-64 0a64 64 0 1 0 128 0 64 64 0 1 0-128 0Z\" fill=\"white\" p-id=\"5393\"></path></svg>\n    `\n    button.setAttribute('aria-label', 'Open AI Assistant')\n\n    // 创建聊天面板\n    const chat = document.createElement('div')\n    chat.className = 'opencode-chat'\n\n    // 创建会话列表\n    const sessionList = document.createElement('div')\n    sessionList.className = 'opencode-session-list collapsed'\n\n    // 创建折叠按钮\n    const toggleBtn = document.createElement('button')\n    toggleBtn.className = 'opencode-session-toggle'\n    toggleBtn.innerHTML = `\n      <svg viewBox=\"0 0 24 24\" width=\"16\" height=\"16\" xmlns=\"http://www.w3.org/2000/svg\">\n        <path d=\"M4 6h16M4 12h16M4 18h16\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>\n      </svg>\n    `\n    toggleBtn.title = '展开会话列表'\n\n    // 创建会话列表头部\n    const sessionListHeader = document.createElement('div')\n    sessionListHeader.className = 'opencode-session-list-header'\n    sessionListHeader.innerHTML = `\n      <span>会话列表</span>\n      <button class=\"opencode-new-session-btn\" title=\"新建会话\">+</button>\n    `\n\n    // 创建会话列表内容\n    const sessionListContent = document.createElement('div')\n    sessionListContent.className = 'opencode-session-list-content'\n\n    sessionList.appendChild(toggleBtn)\n    sessionList.appendChild(sessionListHeader)\n    sessionList.appendChild(sessionListContent)\n\n    // 折叠/展开会话列表\n    let isSessionListCollapsed = true\n    function toggleSessionList() {\n      isSessionListCollapsed = !isSessionListCollapsed\n      sessionList.classList.toggle('collapsed', isSessionListCollapsed)\n      toggleBtn.title = isSessionListCollapsed ? '展开会话列表' : '折叠会话列表'\n    }\n    toggleBtn.addEventListener('click', toggleSessionList)\n\n    // 创建 iframe 容器\n    const iframeContainer = document.createElement('div')\n    iframeContainer.className = 'opencode-iframe-container'\n\n    // 创建加载指示器\n    const loadingOverlay = document.createElement('div')\n    loadingOverlay.className = 'opencode-loading-overlay'\n    loadingOverlay.innerHTML = `\n      <div class=\"opencode-loading-spinner\"></div>\n      <div class=\"opencode-loading-text\">加载中...</div>\n    `\n\n    // 创建 iframe\n    const iframe = document.createElement('iframe')\n    iframe.className = 'opencode-iframe'\n    iframe.src = servicesStarted ? iframeUrl : 'about:blank'\n    iframe.allow = 'clipboard-write; clipboard-read'\n    iframe.referrerPolicy = 'origin'\n\n    iframe.onload = function() {\n      if (servicesStarted) {\n        updateContext()\n        loadSessions()\n      }\n      hideLoading()\n    }\n\n    iframeContainer.appendChild(loadingOverlay)\n    iframeContainer.appendChild(iframe)\n\n    // 创建右侧工具栏\n    const rightToolbar = document.createElement('div')\n    rightToolbar.className = `opencode-right-toolbar${selectedElements.length === 0 ? ' collapsed' : ''}`\n\n    // 创建元素选择按钮\n    const selectButton = document.createElement('button')\n    selectButton.className = 'opencode-select-btn'\n    selectButton.innerHTML = `\n      <svg viewBox=\"0 0 1024 1024\" width=\"18\" height=\"18\" xmlns=\"http://www.w3.org/2000/svg\">\n        <path fill=\"currentColor\" d=\"M512 896a384 384 0 1 0 0-768 384 384 0 0 0 0 768m0 64a448 448 0 1 1 0-896 448 448 0 0 1 0 896\"></path><path fill=\"currentColor\" d=\"M512 96a32 32 0 0 1 32 32v192a32 32 0 0 1-64 0V128a32 32 0 0 1 32-32m0 576a32 32 0 0 1 32 32v192a32 32 0 1 1-64 0V704a32 32 0 0 1 32-32M96 512a32 32 0 0 1 32-32h192a32 32 0 0 1 0 64H128a32 32 0 0 1-32-32m576 0a32 32 0 0 1 32-32h192a32 32 0 1 1 0 64H704a32 32 0 0 1-32-32\"></path>\n      </svg>\n    `\n    selectButton.title = '选择页面元素'\n\n    // 创建已选节点容器\n    const selectedNodesContainer = document.createElement('div')\n    selectedNodesContainer.className = 'opencode-selected-nodes'\n\n    rightToolbar.appendChild(selectButton)\n    rightToolbar.appendChild(selectedNodesContainer)\n\n    // 创建选择模式常驻提示（固定到页面顶部）\n    const selectModeHint = document.createElement('div')\n    selectModeHint.className = 'opencode-select-mode-hint'\n    selectModeHint.innerHTML = `\n      <span>🎯 选择模式已开启 - 点击元素进行选择</span>\n      <span class=\"opencode-hint-shortcut\">按 ESC 退出</span>\n    `\n\n    // 创建已选节点气泡容器（气泡按钮上方）\n    const selectedBubbles = document.createElement('div')\n    selectedBubbles.className = 'opencode-selected-bubbles'\n\n    chat.appendChild(sessionList)\n    chat.appendChild(iframeContainer)\n    chat.appendChild(rightToolbar)\n\n    container.appendChild(button)\n    container.appendChild(selectedBubbles)\n    container.appendChild(chat)\n    document.body.appendChild(container)\n    document.body.appendChild(selectModeHint)\n\n    if (selectedElements.length > 0) {\n      renderSelectedNodes()\n    }\n\n    /** @type {Array} 会话列表 */\n    let sessions = []\n\n    /** @type {string|null} 当前会话 ID */\n    let currentSessionId = null\n\n    /**\n     * 从 URL 中提取会话 ID\n     */\n    function extractSessionId(url) {\n      if (!url) return null\n      const match = url.match(/\\/session\\/([^/?]+)/)\n      return match ? match[1] : null\n    }\n\n    // 从初始 URL 中提取会话 ID\n    currentSessionId = extractSessionId(sessionUrl)\n\n    /**\n     * 显示加载状态\n     */\n    function showLoading() {\n      loadingOverlay.classList.add('visible')\n    }\n\n    /**\n     * 隐藏加载状态\n     */\n    function hideLoading() {\n      loadingOverlay.classList.remove('visible')\n    }\n\n    /**\n     * 加载会话列表\n     */\n    async function loadSessions() {\n      try {\n        const response = await fetch('/__opencode_sessions__')\n        sessions = await response.json()\n        renderSessionList()\n      } catch (e) {\n        console.error('Failed to load sessions:', e)\n      }\n    }\n\n    /**\n     * 渲染会话列表\n     */\n    function renderSessionList() {\n      sessionListContent.innerHTML = ''\n      \n      const currentProjectSessions = sessions.filter(session => session.directory === cwd)\n      \n      currentProjectSessions.forEach(session => {\n        const item = document.createElement('div')\n        item.className = 'opencode-session-item'\n        if (session.id === currentSessionId) {\n          item.classList.add('active')\n        }\n        \n        const header = document.createElement('div')\n        header.className = 'opencode-session-header'\n        \n        const title = document.createElement('div')\n        title.className = 'opencode-session-title'\n        title.textContent = session.title || '新会话'\n        \n        const deleteBtn = document.createElement('button')\n        deleteBtn.className = 'opencode-session-delete-btn'\n        deleteBtn.innerHTML = '×'\n        deleteBtn.title = '删除会话'\n        deleteBtn.addEventListener('click', (e) => {\n          e.stopPropagation()\n          confirmDeleteSession(session)\n        })\n        \n        header.appendChild(title)\n        header.appendChild(deleteBtn)\n        \n        const meta = document.createElement('div')\n        meta.className = 'opencode-session-meta'\n        const date = new Date(session.time.updated)\n        meta.textContent = date.toLocaleDateString() + ' ' + date.toLocaleTimeString()\n        \n        item.appendChild(header)\n        item.appendChild(meta)\n        \n        item.addEventListener('click', () => {\n          switchSession(session)\n        })\n        \n        sessionListContent.appendChild(item)\n      })\n    }\n\n    /**\n     * 切换会话\n     */\n    function switchSession(session) {\n      if (session.id === currentSessionId) {\n        return\n      }\n      \n      currentSessionId = session.id\n      const encodedDir = btoa(cwd)\n      const baseUrl = iframeUrl.split('/').slice(0, 3).join('/')\n      showLoading()\n      iframe.src = `${baseUrl}/${encodedDir}/session/${session.id}`\n      renderSessionList()\n    }\n\n    /**\n     * 创建新会话\n     */\n    async function createNewSession() {\n      try {\n        const response = await fetch('/__opencode_sessions__', {\n          method: 'POST'\n        })\n        const newSession = await response.json()\n        sessions.unshift(newSession)\n        switchSession(newSession)\n      } catch (e) {\n        console.error('Failed to create session:', e)\n        showNotification('创建会话失败')\n      }\n    }\n\n    /**\n     * 确认删除会话\n     */\n    function confirmDeleteSession(session) {\n      const confirmed = confirm(`确定要删除会话 \"${session.title || '新会话'}\" 吗？`)\n      if (confirmed) {\n        deleteSession(session)\n      }\n    }\n\n    /**\n     * 删除会话\n     */\n    async function deleteSession(session) {\n      try {\n        const response = await fetch(`/__opencode_sessions__?id=${session.id}`, {\n          method: 'DELETE'\n        })\n        \n        if (!response.ok) {\n          throw new Error('Delete failed')\n        }\n        \n        sessions = sessions.filter(s => s.id !== session.id)\n        \n        if (session.id === currentSessionId) {\n          const remainingSessions = sessions.filter(s => s.directory === cwd)\n          if (remainingSessions.length > 0) {\n            switchSession(remainingSessions[0])\n          } else {\n            currentSessionId = null\n            iframe.src = 'about:blank'\n          }\n        }\n        \n        renderSessionList()\n        showNotification('会话已删除')\n      } catch (e) {\n        console.error('Failed to delete session:', e)\n        showNotification('删除会话失败')\n      }\n    }\n\n    // 绑定新建会话按钮\n    sessionListHeader.querySelector('.opencode-new-session-btn').addEventListener('click', createNewSession)\n\n    /**\n     * 应用主题\n     */\n    function applyTheme() {\n      if (theme === 'auto') {\n        const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches\n        container.classList.toggle('opencode-dark', prefersDark)\n      } else {\n        container.classList.toggle('opencode-dark', theme === 'dark')\n      }\n    }\n\n    applyTheme()\n\n    if (theme === 'auto') {\n      window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', applyTheme)\n    }\n\n    /**\n     * 切换挂件显示状态\n     */\n    async function toggle() {\n      if (lazy && !servicesStarted) {\n        button.classList.add('loading')\n        const started = await ensureServicesStarted()\n        button.classList.remove('loading')\n        if (!started) {\n          showNotification('服务启动失败，请检查控制台')\n          return\n        }\n      }\n\n      isOpen = !isOpen\n      chat.classList.toggle('open', isOpen)\n      button.classList.toggle('active', isOpen)\n\n      if (isOpen) {\n        updateContext()\n      }\n    }\n\n    button.addEventListener('click', toggle)\n\n    document.addEventListener('keydown', (e) => {\n      if (matchHotkey(e, mainHotkey)) {\n        e.preventDefault()\n        toggle()\n      }\n    })\n\n    if (open && servicesStarted) {\n      setTimeout(() => {\n        toggle()\n      }, AUTO_OPEN_DELAY)\n    }\n\n    /**\n     * 显示通知\n     * @param {string} message - 通知消息\n     */\n    function showNotification(message) {\n      const notification = document.createElement('div')\n      notification.className = 'opencode-notification'\n      notification.textContent = message\n      chat.appendChild(notification)\n\n      setTimeout(() => {\n        notification.remove()\n      }, NOTIFICATION_DURATION)\n    }\n\n    /**\n     * 添加选中元素\n     * @param {SelectedElement} elementInfo - 元素信息\n     */\n    function addElement(elementInfo) {\n      const key = elementInfo.filePath && elementInfo.line\n        ? `${elementInfo.filePath}:${elementInfo.line}`\n        : null\n\n      const exists = key && selectedElements.some(el => {\n        const elKey = el.filePath && el.line ? `${el.filePath}:${el.line}` : null\n        return elKey === key\n      })\n\n      if (!exists) {\n        selectedElements.push(elementInfo)\n        saveSelectedElements(selectedElements)\n        renderSelectedNodes()\n        if (isSelectMode) {\n          renderSelectedBubbles()\n        }\n        showNotification(`已选中元素 (${selectedElements.length}个)`)\n      } else {\n        showNotification('该元素已选中')\n      }\n    }\n\n    /**\n     * 移除选中元素\n     * @param {number} index - 元素索引\n     */\n    function removeElement(index) {\n      selectedElements.splice(index, 1)\n      saveSelectedElements(selectedElements)\n      renderSelectedNodes()\n      updateToolbarState()\n      sendSelectedElements()\n    }\n\n    /**\n     * 清除所有选中元素\n     */\n    function clearAllElements() {\n      selectedElements = []\n      saveSelectedElements(selectedElements)\n      renderSelectedNodes()\n      updateToolbarState()\n      sendSelectedElements()\n      showNotification('已清除所有选中元素')\n    }\n\n    /**\n     * 更新工具栏状态\n     */\n    function updateToolbarState() {\n      if (selectedElements.length > 0) {\n        rightToolbar.classList.remove('collapsed')\n      } else {\n        rightToolbar.classList.add('collapsed')\n      }\n    }\n\n    /** @type {boolean} 是否处于元素选择模式 */\n    let isSelectMode = false\n\n    /**\n     * 切换元素选择模式\n     */\n    function toggleSelectMode() {\n      const inspector = window.__VUE_INSPECTOR__\n      \n      if (!inspector) {\n        showNotification('Vue Inspector 未加载，无法使用元素选择功能')\n        return\n      }\n      \n      isSelectMode = !isSelectMode\n      selectButton.classList.toggle('active', isSelectMode)\n      selectModeHint.classList.toggle('visible', isSelectMode)\n      selectedBubbles.classList.toggle('visible', isSelectMode)\n      \n      if (isSelectMode) {\n        chat.style.display = 'none'\n        inspector.enable()\n        renderSelectedBubbles()\n      } else {\n        chat.style.display = ''\n        inspector.disable()\n      }\n    }\n\n    /**\n     * 退出选择模式\n     */\n    function exitSelectMode() {\n      if (!isSelectMode) return\n      \n      const inspector = window.__VUE_INSPECTOR__\n      if (inspector) {\n        inspector.disable()\n      }\n      \n      isSelectMode = false\n      selectButton.classList.remove('active')\n      selectModeHint.classList.remove('visible')\n      selectedBubbles.classList.remove('visible')\n      chat.style.display = ''\n    }\n\n    // ESC 键退出选择模式\n    document.addEventListener('keydown', (e) => {\n      if (e.key === 'Escape' && isSelectMode) {\n        exitSelectMode()\n      }\n    })\n\n    /**\n     * 渲染已选节点气泡\n     */\n    function renderSelectedBubbles() {\n      selectedBubbles.innerHTML = ''\n      \n      if (selectedElements.length === 0) {\n        selectedBubbles.innerHTML = '<div class=\"opencode-bubble-empty\">暂无选中元素</div>'\n        return\n      }\n      \n      selectedElements.forEach((element, index) => {\n        const bubble = document.createElement('div')\n        bubble.className = 'opencode-selected-bubble'\n        \n        const description = element.description || '未知元素'\n        const fileName = element.filePath ? element.filePath.split('/').pop() : ''\n        const lineInfo = element.line ? `:${element.line}` : ''\n        \n        bubble.innerHTML = `\n          <span class=\"opencode-bubble-text\">${description}</span>\n          ${fileName ? `<span class=\"opencode-bubble-file\">${fileName}${lineInfo}</span>` : ''}\n          <button class=\"opencode-bubble-remove\" data-index=\"${index}\">×</button>\n        `\n        \n        bubble.querySelector('.opencode-bubble-remove').addEventListener('click', (e) => {\n          e.stopPropagation()\n          removeElement(index)\n          renderSelectedBubbles()\n        })\n        \n        selectedBubbles.appendChild(bubble)\n      })\n    }\n    function renderSelectedNodes() {\n      selectedNodesContainer.innerHTML = ''\n      \n      if (selectedElements.length === 0) {\n        rightToolbar.classList.add('collapsed')\n      } else {\n        rightToolbar.classList.remove('collapsed')\n      }\n      \n      selectedElements.forEach((element, index) => {\n        const node = document.createElement('div')\n        node.className = 'opencode-selected-node'\n        \n        const description = element.description || '未知元素'\n        const textPreview = element.innerText ? element.innerText.substring(0, 30) : ''\n        const fileName = element.filePath ? element.filePath.split('/').pop() : '未知文件'\n        const lineInfo = element.line ? `:${element.line}` : ''\n        \n        node.innerHTML = `\n          <div class=\"opencode-node-content\">\n            <span class=\"opencode-node-text\">${description}</span>\n            <span class=\"opencode-node-file\">${textPreview ? textPreview + ' · ' : ''}${fileName}${lineInfo}</span>\n          </div>\n          <button class=\"opencode-node-remove\" data-index=\"${index}\">×</button>\n        `\n        \n        node.querySelector('.opencode-node-remove').addEventListener('click', (e) => {\n          e.stopPropagation()\n          removeElement(index)\n        })\n        \n        selectedNodesContainer.appendChild(node)\n      })\n    }\n\n    // 绑定选择按钮点击事件\n    selectButton.addEventListener('click', toggleSelectMode)\n\n    /**\n     * 发送选中元素到服务器\n     */\n    function sendSelectedElements() {\n      if (!servicesStarted) return\n\n      fetch('/__opencode_context__', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({\n          url: currentPageUrl,\n          title: currentPageTitle,\n          selectedElements: selectedElements\n        })\n      }).catch(() => {})\n    }\n\n    /**\n     * 与服务器同步选中元素\n     */\n    function syncWithServer() {\n      if (!servicesStarted) return\n\n      fetch('/__opencode_context__')\n        .then(res => res.json())\n        .then(data => {\n          if (data.selectedElements && data.selectedElements.length === 0 && selectedElements.length > 0) {\n            selectedElements = []\n            saveSelectedElements(selectedElements)\n            renderSelectedNodes()\n          }\n        })\n        .catch(() => {})\n    }\n\n    setInterval(syncWithServer, SERVER_SYNC_INTERVAL)\n\n    /**\n     * 截断字符串\n     * @param {string} str - 原字符串\n     * @param {number} maxLength - 最大长度\n     * @returns {string} 截断后的字符串\n     */\n    function truncate(str, maxLength) {\n      if (!str) return ''\n      return str.length > maxLength ? str.substring(0, maxLength) + '...' : str\n    }\n\n    /**\n     * 获取元素的直接文本内容\n     * @param {Element} element - DOM 元素\n     * @returns {string} 直接文本内容\n     */\n    function getDirectText(element) {\n      let text = ''\n      for (const child of element.childNodes) {\n        if (child.nodeType === Node.TEXT_NODE) {\n          text += child.textContent || ''\n        }\n      }\n      return text.trim()\n    }\n\n    /**\n     * 获取元素描述信息\n     * @param {Element} element - DOM 元素\n     * @returns {string} 元素描述\n     */\n    function getElementDescription(element) {\n      const tag = element.tagName.toLowerCase()\n      const parts = [tag]\n      \n      const id = element.id\n      if (id) parts.push(`#${id}`)\n      \n      const className = element.className && typeof element.className === 'string'\n        ? element.className.trim().split(/\\s+/).filter(Boolean).slice(0, 2).join('.')\n        : ''\n      if (className) parts.push(`.${className}`)\n      \n      const name = element.getAttribute('name')\n      if (name) parts.push(`[name=\"${name}\"]`)\n      \n      const placeholder = element.getAttribute('placeholder')\n      if (placeholder) parts.push(`[placeholder=\"${placeholder.substring(0, 20)}\"]`)\n      \n      const src = element.getAttribute('src')\n      if (src) parts.push(`[src]`)\n      \n      const href = element.getAttribute('href')\n      if (href && href !== '#') parts.push(`[href]`)\n      \n      return parts.join('')\n    }\n\n    /**\n     * 设置 Vue Inspector 钩子\n     */\n    function setupInspectorHook() {\n      if (window.__VUE_INSPECTOR__) {\n        const inspector = window.__VUE_INSPECTOR__\n        const originalHandleClick = inspector.handleClick.bind(inspector)\n\n        inspector.handleClick = function(e) {\n          if (isSelectMode) {\n            const { targetNode, params } = inspector.getTargetNode(e)\n            if (targetNode && params) {\n              const innerText = getDirectText(targetNode)\n              const description = getElementDescription(targetNode)\n\n              const elementInfo = {\n                filePath: params.file,\n                line: params.line,\n                column: params.column,\n                innerText: truncate(innerText, 200),\n                description\n              }\n              addElement(elementInfo)\n              sendSelectedElements()\n            }\n            return\n          }\n\n          return originalHandleClick.call(inspector, e)\n        }\n      }\n    }\n\n    if (window.__VUE_INSPECTOR__) {\n      setupInspectorHook()\n    } else {\n      const checkInspector = setInterval(() => {\n        if (window.__VUE_INSPECTOR__) {\n          setupInspectorHook()\n          clearInterval(checkInspector)\n        }\n      }, INSPECTOR_CHECK_INTERVAL)\n    }\n\n    // 导出全局 API\n    window.OpenCodeWidget = {\n      open: () => { if (!isOpen) toggle() },\n      close: () => { if (isOpen) toggle() },\n      toggle,\n      showNotification,\n      updateContext,\n    }\n  }\n\n  /**\n   * 构建挂件样式\n   * @returns {string} CSS 样式字符串\n   */\n  function buildWidgetStyles() {\n    return `\n      .opencode-widget {\n        position: fixed;\n        z-index: 999999;\n        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;\n      }\n\n      .opencode-widget.bottom-right {\n        bottom: 20px;\n        right: 20px;\n      }\n\n      .opencode-widget.bottom-left {\n        bottom: 20px;\n        left: 20px;\n      }\n\n      .opencode-widget.top-right {\n        top: 20px;\n        right: 20px;\n      }\n\n      .opencode-widget.top-left {\n        top: 20px;\n        left: 20px;\n      }\n\n      .opencode-button {\n        width: 60px;\n        height: 60px;\n        border-radius: 50%;\n        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);\n        border: none;\n        cursor: pointer;\n        box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);\n        transition: all 0.3s ease;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        color: white;\n        padding: 0;\n      }\n\n      .opencode-button:hover {\n        transform: scale(1.1);\n        box-shadow: 0 6px 20px rgba(102, 126, 234, 0.6);\n        background: linear-gradient(135deg, #764ba2 0%, #667eea 100%);\n      }\n\n      .opencode-button.active {\n        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);\n        box-shadow: 0 6px 20px rgba(240, 147, 251, 0.4);\n        transform: rotate(180deg);\n      }\n\n      .opencode-button.loading {\n        animation: pulse 1s infinite;\n      }\n\n      @keyframes pulse {\n        0%, 100% { opacity: 1; }\n        50% { opacity: 0.5; }\n      }\n\n      .opencode-chat {\n        position: absolute;\n        width: 700px;\n        height: 80vh;\n        background: white;\n        border-radius: 16px;\n        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.12);\n        overflow: hidden;\n        opacity: 0;\n        visibility: hidden;\n        transform: translateY(20px) scale(0.95);\n        transition: all 0.3s ease;\n        display: flex;\n      }\n\n      .opencode-widget.bottom-right .opencode-chat {\n        bottom: 80px;\n        right: 0;\n      }\n\n      .opencode-widget.bottom-left .opencode-chat {\n        bottom: 80px;\n        left: 0;\n      }\n\n      .opencode-widget.top-right .opencode-chat {\n        top: 80px;\n        right: 0;\n      }\n\n      .opencode-widget.top-left .opencode-chat {\n        top: 80px;\n        left: 0;\n      }\n\n      .opencode-chat.open {\n        opacity: 1;\n        visibility: visible;\n        transform: translateY(0) scale(1);\n      }\n\n      .opencode-session-list {\n        width: 240px;\n        background: #f8f9fa;\n        border-right: 1px solid #e5e7eb;\n        display: flex;\n        flex-direction: column;\n        flex-shrink: 0;\n        transition: width 0.2s ease;\n      }\n\n      .opencode-session-list.collapsed {\n        width: 40px;\n      }\n\n      .opencode-session-toggle {\n        width: 100%;\n        height: 40px;\n        border: none;\n        background: transparent;\n        color: #6b7280;\n        cursor: pointer;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        transition: all 0.2s;\n        border-bottom: 1px solid #e5e7eb;\n      }\n\n      .opencode-session-toggle:hover {\n        background: #e5e7eb;\n        color: #374151;\n      }\n\n      .opencode-session-list.collapsed .opencode-session-list-header,\n      .opencode-session-list.collapsed .opencode-session-list-content {\n        display: none;\n      }\n\n      .opencode-session-list-header {\n        padding: 16px;\n        border-bottom: 1px solid #e5e7eb;\n        display: flex;\n        justify-content: space-between;\n        align-items: center;\n        font-weight: 600;\n        font-size: 14px;\n        color: #374151;\n      }\n\n      .opencode-new-session-btn {\n        width: 28px;\n        height: 28px;\n        border-radius: 6px;\n        border: none;\n        background: #3b82f6;\n        color: white;\n        font-size: 18px;\n        cursor: pointer;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        transition: all 0.2s;\n      }\n\n      .opencode-new-session-btn:hover {\n        background: #2563eb;\n        transform: scale(1.05);\n      }\n\n      .opencode-session-list-content {\n        flex: 1;\n        overflow-y: auto;\n        padding: 8px;\n      }\n\n      .opencode-session-item {\n        padding: 12px;\n        border-radius: 8px;\n        cursor: pointer;\n        transition: all 0.2s;\n        margin-bottom: 4px;\n      }\n\n      .opencode-session-item:hover {\n        background: #e5e7eb;\n      }\n\n      .opencode-session-item.active {\n        background: #3b82f6;\n        color: white;\n      }\n\n      .opencode-session-title {\n        font-size: 14px;\n        font-weight: 500;\n        margin-bottom: 4px;\n        overflow: hidden;\n        text-overflow: ellipsis;\n        white-space: nowrap;\n      }\n\n      .opencode-session-meta {\n        font-size: 12px;\n        opacity: 0.6;\n      }\n\n      .opencode-session-header {\n        display: flex;\n        justify-content: space-between;\n        align-items: center;\n        margin-bottom: 4px;\n      }\n\n      .opencode-session-delete-btn {\n        width: 20px;\n        height: 20px;\n        border-radius: 4px;\n        border: none;\n        background: transparent;\n        color: #6b7280;\n        font-size: 16px;\n        cursor: pointer;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        transition: all 0.2s;\n        opacity: 0;\n        flex-shrink: 0;\n      }\n\n      .opencode-session-item:hover .opencode-session-delete-btn {\n        opacity: 1;\n      }\n\n      .opencode-session-delete-btn:hover {\n        background: #ef4444;\n        color: white;\n      }\n\n      .opencode-session-item.active .opencode-session-delete-btn {\n        color: rgba(255, 255, 255, 0.7);\n      }\n\n      .opencode-session-item.active .opencode-session-delete-btn:hover {\n        background: rgba(255, 255, 255, 0.2);\n        color: white;\n      }\n\n      .opencode-iframe-container {\n        flex: 1;\n        position: relative;\n        overflow: hidden;\n        display: flex;\n        flex-direction: column;\n      }\n\n      .opencode-loading-overlay {\n        position: absolute;\n        top: 0;\n        left: 0;\n        right: 0;\n        bottom: 0;\n        background: rgba(255, 255, 255, 0.9);\n        display: none;\n        flex-direction: column;\n        align-items: center;\n        justify-content: center;\n        z-index: 10;\n        transition: opacity 0.3s ease;\n      }\n\n      .opencode-loading-overlay.visible {\n        display: flex;\n      }\n\n      .opencode-loading-spinner {\n        width: 40px;\n        height: 40px;\n        border: 3px solid #e5e7eb;\n        border-top-color: #3b82f6;\n        border-radius: 50%;\n        animation: spin 0.8s linear infinite;\n      }\n\n      @keyframes spin {\n        to { transform: rotate(360deg); }\n      }\n\n      .opencode-loading-text {\n        margin-top: 12px;\n        font-size: 14px;\n        color: #6b7280;\n      }\n\n      .opencode-iframe {\n        position: absolute;\n        top: -136px;\n        width: 100%;\n        height: calc(100% + 136px);\n        border: none;\n        transition: opacity 0.3s ease;\n      }\n\n      .opencode-dark .opencode-chat {\n        background: #1a1a1a;\n      }\n\n      .opencode-dark .opencode-session-list {\n        background: #111827;\n        border-right-color: #374151;\n      }\n\n      .opencode-dark .opencode-session-toggle {\n        color: #9ca3af;\n        border-bottom-color: #374151;\n      }\n\n      .opencode-dark .opencode-session-toggle:hover {\n        background: #374151;\n        color: #f3f4f6;\n      }\n\n      .opencode-dark .opencode-session-list-header {\n        border-bottom-color: #374151;\n        color: #f3f4f6;\n      }\n\n      .opencode-dark .opencode-session-item:hover {\n        background: #374151;\n      }\n\n      .opencode-dark .opencode-session-item.active {\n        background: #3b82f6;\n      }\n\n      .opencode-dark .opencode-loading-overlay {\n        background: rgba(26, 26, 26, 0.9);\n      }\n\n      .opencode-dark .opencode-loading-spinner {\n        border-color: #374151;\n        border-top-color: #3b82f6;\n      }\n\n      .opencode-dark .opencode-loading-text {\n        color: #9ca3af;\n      }\n\n      .opencode-right-toolbar {\n        width: 140px;\n        background: #f8f9fa;\n        border-left: 1px solid #e5e7eb;\n        display: flex;\n        flex-direction: column;\n        flex-shrink: 0;\n        transition: width 0.2s ease;\n      }\n\n      .opencode-right-toolbar.collapsed {\n        width: 40px;\n      }\n\n      .opencode-right-toolbar.collapsed .opencode-selected-nodes {\n        display: none;\n      }\n\n      .opencode-select-btn {\n        width: 100%;\n        height: 44px;\n        border: none;\n        background: transparent;\n        color: #6b7280;\n        cursor: pointer;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        gap: 8px;\n        transition: all 0.2s;\n        border-bottom: 1px solid #e5e7eb;\n        font-size: 13px;\n        font-weight: 500;\n      }\n\n      .opencode-select-btn:hover {\n        background: #e5e7eb;\n        color: #374151;\n      }\n\n      .opencode-select-btn.active {\n        background: #3b82f6;\n        color: white;\n      }\n\n      .opencode-selected-nodes {\n        flex: 1;\n        display: flex;\n        flex-direction: column;\n        padding: 8px;\n        gap: 6px;\n        overflow-y: auto;\n        overflow-x: hidden;\n      }\n\n      .opencode-selected-nodes:empty::before {\n        content: '暂无选中元素';\n        color: #9ca3af;\n        font-size: 12px;\n        text-align: center;\n        padding: 20px 10px;\n      }\n\n      .opencode-selected-node {\n        display: flex;\n        align-items: center;\n        gap: 8px;\n        padding: 8px 10px;\n        background: white;\n        border: 1px solid #e5e7eb;\n        border-radius: 6px;\n        font-size: 12px;\n        transition: all 0.2s;\n      }\n\n      .opencode-selected-node:hover {\n        border-color: #3b82f6;\n        box-shadow: 0 2px 4px rgba(59, 130, 246, 0.1);\n      }\n\n      .opencode-node-content {\n        flex: 1;\n        min-width: 0;\n        display: flex;\n        flex-direction: column;\n        gap: 2px;\n      }\n\n      .opencode-node-text {\n        color: #374151;\n        font-weight: 500;\n        overflow: hidden;\n        text-overflow: ellipsis;\n        white-space: nowrap;\n      }\n\n      .opencode-node-file {\n        color: #9ca3af;\n        font-size: 11px;\n        overflow: hidden;\n        text-overflow: ellipsis;\n        white-space: nowrap;\n      }\n\n      .opencode-node-remove {\n        width: 18px;\n        height: 18px;\n        border-radius: 4px;\n        border: none;\n        background: transparent;\n        color: #9ca3af;\n        cursor: pointer;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        font-size: 14px;\n        transition: all 0.2s;\n        flex-shrink: 0;\n      }\n\n      .opencode-node-remove:hover {\n        background: #ef4444;\n        color: white;\n      }\n\n      .opencode-dark .opencode-right-toolbar {\n        background: #111827;\n        border-left-color: #374151;\n      }\n\n      .opencode-dark .opencode-select-btn {\n        color: #9ca3af;\n        border-bottom-color: #374151;\n      }\n\n      .opencode-dark .opencode-select-btn:hover {\n        background: #374151;\n        color: #f3f4f6;\n      }\n\n      .opencode-dark .opencode-selected-nodes:empty::before {\n        color: #6b7280;\n      }\n\n      .opencode-dark .opencode-selected-node {\n        background: #1f2937;\n        border-color: #374151;\n      }\n\n      .opencode-dark .opencode-selected-node:hover {\n        border-color: #3b82f6;\n      }\n\n      .opencode-dark .opencode-node-text {\n        color: #f3f4f6;\n      }\n\n      .opencode-dark .opencode-node-file {\n        color: #6b7280;\n      }\n\n      .opencode-dark .opencode-node-remove {\n        color: #6b7280;\n      }\n\n      .opencode-dark .opencode-node-remove:hover {\n        background: #ef4444;\n        color: white;\n      }\n\n      .opencode-dark .opencode-button {\n        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);\n        box-shadow: 0 4px 15px rgba(102, 126, 234, 0.5);\n      }\n\n      .opencode-notification {\n        position: absolute;\n        top: 20px;\n        left: 50%;\n        transform: translateX(-50%);\n        padding: 12px 20px;\n        background: #10b981;\n        color: white;\n        border-radius: 8px;\n        font-size: 14px;\n        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);\n        animation: slideDown 0.3s ease;\n        z-index: 10;\n      }\n\n      @keyframes slideDown {\n        from {\n          transform: translateX(-50%) translateY(-100%);\n          opacity: 0;\n        }\n        to {\n          transform: translateX(-50%) translateY(0);\n          opacity: 1;\n        }\n      }\n\n      .opencode-select-mode-hint {\n        position: fixed;\n        top: 20px;\n        left: 50%;\n        transform: translateX(-50%);\n        padding: 10px 16px;\n        background: #3b82f6;\n        color: white;\n        border-radius: 8px;\n        font-size: 13px;\n        box-shadow: 0 4px 12px rgba(59, 130, 246, 0.3);\n        z-index: 9999999;\n        display: none;\n        align-items: center;\n        gap: 12px;\n      }\n\n      .opencode-select-mode-hint.visible {\n        display: flex;\n        animation: slideDown 0.3s ease;\n      }\n\n      .opencode-hint-shortcut {\n        padding: 2px 6px;\n        background: rgba(255, 255, 255, 0.2);\n        border-radius: 4px;\n        font-size: 12px;\n      }\n\n      .opencode-selected-bubbles {\n        position: absolute;\n        bottom: 70px;\n        right: 0;\n        display: none;\n        flex-direction: column;\n        gap: 6px;\n        max-width: 220px;\n        max-height: 300px;\n        overflow-y: auto;\n      }\n\n      .opencode-selected-bubbles.visible {\n        display: flex;\n      }\n\n      .opencode-selected-bubble {\n        display: flex;\n        flex-direction: column;\n        gap: 2px;\n        padding: 8px 10px;\n        background: white;\n        border: 1px solid #e5e7eb;\n        border-radius: 8px;\n        font-size: 12px;\n        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);\n        position: relative;\n      }\n\n      .opencode-bubble-text {\n        color: #374151;\n        font-weight: 500;\n        overflow: hidden;\n        text-overflow: ellipsis;\n        white-space: nowrap;\n      }\n\n      .opencode-bubble-file {\n        color: #9ca3af;\n        font-size: 11px;\n        overflow: hidden;\n        text-overflow: ellipsis;\n        white-space: nowrap;\n      }\n\n      .opencode-bubble-remove {\n        position: absolute;\n        top: 4px;\n        right: 4px;\n        width: 16px;\n        height: 16px;\n        border-radius: 50%;\n        border: none;\n        background: transparent;\n        color: #9ca3af;\n        cursor: pointer;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        font-size: 12px;\n        transition: all 0.2s;\n      }\n\n      .opencode-bubble-remove:hover {\n        background: #ef4444;\n        color: white;\n      }\n\n      .opencode-bubble-empty {\n        padding: 8px 12px;\n        background: white;\n        border: 1px dashed #d1d5db;\n        border-radius: 8px;\n        color: #9ca3af;\n        font-size: 12px;\n        text-align: center;\n      }\n\n      .opencode-dark .opencode-selected-bubble {\n        background: #1f2937;\n        border-color: #374151;\n      }\n\n      .opencode-dark .opencode-bubble-text {\n        color: #f3f4f6;\n      }\n\n      .opencode-dark .opencode-bubble-file {\n        color: #6b7280;\n      }\n\n      .opencode-dark .opencode-bubble-remove {\n        color: #6b7280;\n      }\n\n      .opencode-dark .opencode-bubble-empty {\n        background: #1f2937;\n        border-color: #374151;\n        color: #6b7280;\n      }\n\n      @media (max-width: 768px) {\n        .opencode-chat {\n          width: calc(100vw - 40px);\n          height: calc(100vh - 120px);\n        }\n      }\n    `\n  }\n\n  /**\n   * 自动初始化挂件\n   */\n  function autoInit() {\n    const script = document.currentScript || document.querySelector('script[data-opencode-config]')\n    if (script) {\n      const configBase64 = script.getAttribute('data-opencode-config')\n      if (configBase64) {\n        try {\n          const config = JSON.parse(atob(configBase64))\n          if (document.readyState === 'loading') {\n            document.addEventListener('DOMContentLoaded', function() {\n              initOpenCodeWidget(config)\n            })\n          } else {\n            initOpenCodeWidget(config)\n          }\n        } catch (e) {\n          console.error('[OpenCode Widget] Failed to parse config:', e)\n        }\n      }\n    }\n  }\n\n  // 导出全局初始化函数\n  window.initOpenCodeWidget = initOpenCodeWidget\n\n  // 自动初始化\n  autoInit()\n})();"]}