vite-plugin-opencode-assistant 1.0.0

package/dist/index.js

@@ -0,0 +1,448 @@
+import path from 'path';
+import fs from 'fs';
+import http from 'http';
+import { startOpenCodeWeb } from './web';
+import { injectWidget } from './injector';
+import { checkOpenCodeInstalled, findAvailablePort, killProcessOnPort, checkOpenCodeProcess } from './utils';
+import { DEFAULT_CONFIG, DEFAULT_RETRIES, RETRY_DELAY, PROCESS_KILL_DELAY, LOG_PREFIX, WIDGET_SCRIPT_PATH, CONTEXT_API_PATH, START_API_PATH, SESSIONS_API_PATH, } from './constants';
+/**
+ * OpenCode Vite 插件
+ * @param options - 插件配置选项
+ * @returns Vite 插件实例
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import opencode from 'vite-plugin-opencode'
+ *
+ * export default {
+ *   plugins: [
+ *     opencode({
+ *       webPort: 4097,
+ *       position: 'bottom-right',
+ *       theme: 'auto'
+ *     })
+ *   ]
+ * }
+ * ```
+ */
+export default function opencodePlugin(options = {}) {
+    let webProcess = null;
+    let sessionUrl = null;
+    let actualWebPort = DEFAULT_CONFIG.webPort;
+    let isStarted = false;
+    let startPromise = null;
+    let pageContext = { url: '', title: '' };
+    const config = { ...DEFAULT_CONFIG, ...options };
+    /**
+     * 输出日志（仅在 verbose 模式下）
+     */
+    function log(message, ...args) {
+        if (config.verbose) {
+            console.log(`${LOG_PREFIX} ${message}`, ...args);
+        }
+    }
+    /**
+     * 输出错误日志
+     */
+    function logError(message, ...args) {
+        console.error(`${LOG_PREFIX} ${message}`, ...args);
+    }
+    /**
+     * Base64 编码字符串
+     */
+    function base64Encode(str) {
+        return Buffer.from(str).toString('base64');
+    }
+    /**
+     * 延迟执行
+     */
+    function sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * 创建 HTTP 请求 Promise
+     */
+    function createHttpRequest(options, body) {
+        return new Promise((resolve, reject) => {
+            const req = http.request(options, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    try {
+                        resolve(JSON.parse(data));
+                    }
+                    catch {
+                        reject(new Error(`JSON parse error: ${data.substring(0, 100)}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            if (body)
+                req.write(body);
+            req.end();
+        });
+    }
+    /**
+     * 获取会话列表
+     */
+    async function getSessions(retries = DEFAULT_RETRIES) {
+        let lastError = null;
+        for (let i = 0; i < retries; i++) {
+            try {
+                return await createHttpRequest({
+                    hostname: config.hostname,
+                    port: actualWebPort,
+                    path: '/session',
+                });
+            }
+            catch (e) {
+                lastError = e instanceof Error ? e : new Error(String(e));
+                if (i < retries - 1)
+                    await sleep(RETRY_DELAY);
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * 创建新会话
+     */
+    async function createSession(retries = DEFAULT_RETRIES) {
+        let lastError = null;
+        for (let i = 0; i < retries; i++) {
+            try {
+                return await createHttpRequest({
+                    hostname: config.hostname,
+                    port: actualWebPort,
+                    path: '/session',
+                    method: 'POST',
+                });
+            }
+            catch (e) {
+                lastError = e instanceof Error ? e : new Error(String(e));
+                if (i < retries - 1)
+                    await sleep(RETRY_DELAY);
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * 删除会话
+     */
+    async function deleteSession(sessionId, retries = DEFAULT_RETRIES) {
+        let lastError = null;
+        for (let i = 0; i < retries; i++) {
+            try {
+                await createHttpRequest({
+                    hostname: config.hostname,
+                    port: actualWebPort,
+                    path: `/session/${sessionId}`,
+                    method: 'DELETE',
+                });
+                return;
+            }
+            catch (e) {
+                lastError = e instanceof Error ? e : new Error(String(e));
+                if (i < retries - 1)
+                    await sleep(RETRY_DELAY);
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * 获取或创建会话
+     */
+    async function getOrCreateSession() {
+        const projectDir = process.cwd();
+        log('Getting sessions...');
+        const sessions = await getSessions();
+        log(`Found ${sessions.length} sessions`);
+        const matchingSession = sessions.find(s => s.directory === projectDir);
+        if (matchingSession) {
+            return `http://${config.hostname}:${actualWebPort}/${base64Encode(projectDir)}/session/${matchingSession.id}`;
+        }
+        log('Creating new session...');
+        const newSession = await createSession();
+        return `http://${config.hostname}:${actualWebPort}/${base64Encode(projectDir)}/session/${newSession.id}`;
+    }
+    /**
+     * 设置 OpenCode 插件
+     */
+    function setupOpenCodePlugin() {
+        const projectDir = process.cwd();
+        const cacheDir = path.join(projectDir, 'node_modules', '.cache', 'opencode');
+        const pluginsDir = path.join(cacheDir, 'plugins');
+        if (!fs.existsSync(pluginsDir)) {
+            fs.mkdirSync(pluginsDir, { recursive: true });
+        }
+        const pluginSourcePath = path.join(__dirname, 'plugins', 'page-context.js');
+        const pluginTargetPath = path.join(pluginsDir, 'page-context.js');
+        if (fs.existsSync(pluginSourcePath)) {
+            fs.copyFileSync(pluginSourcePath, pluginTargetPath);
+            log(`Plugin installed to ${pluginTargetPath}`);
+        }
+        else {
+            console.warn(`${LOG_PREFIX} Plugin source not found: ${pluginSourcePath}`);
+        }
+        return cacheDir;
+    }
+    /**
+     * 启动服务
+     */
+    async function startServices(corsOrigins, contextApiUrl) {
+        if (isStarted)
+            return;
+        if (startPromise)
+            return startPromise;
+        startPromise = (async () => {
+            log('Starting OpenCode services...');
+            if (!await checkOpenCodeInstalled()) {
+                logError(`OpenCode is not installed!
+
+Please install OpenCode first:
+
+  # Using Homebrew (macOS)
+  brew install opencode-ai/tap/opencode
+
+  # Or using the install script
+  curl -fsSL https://opencode.ai/install | bash
+        `);
+                return;
+            }
+            actualWebPort = await findAvailablePort(config.webPort, config.hostname);
+            if (actualWebPort !== config.webPort) {
+                log(`Port ${config.webPort} is in use, using ${actualWebPort} instead`);
+            }
+            const existingProcess = await checkOpenCodeProcess(actualWebPort);
+            if (existingProcess) {
+                log(`Found existing OpenCode process on port ${actualWebPort}`);
+            }
+            else {
+                const killed = await killProcessOnPort(actualWebPort, config.hostname);
+                if (killed) {
+                    log(`Killed stale process on port ${actualWebPort}`);
+                    await sleep(PROCESS_KILL_DELAY);
+                }
+            }
+            const configDir = setupOpenCodePlugin();
+            if (!existingProcess) {
+                webProcess = await startOpenCodeWeb({
+                    port: actualWebPort,
+                    hostname: config.hostname,
+                    serverUrl: '',
+                    cwd: process.cwd(),
+                    configDir,
+                    corsOrigins,
+                    contextApiUrl,
+                });
+                log(`OpenCode Web started at http://${config.hostname}:${actualWebPort}`);
+            }
+            try {
+                sessionUrl = await getOrCreateSession();
+                log(`Session URL: ${sessionUrl}`);
+            }
+            catch (e) {
+                console.warn(`${LOG_PREFIX} Failed to get/create session:`, e);
+            }
+            isStarted = true;
+        })();
+        return startPromise;
+    }
+    /**
+     * 停止服务
+     */
+    async function stopServices() {
+        log('Stopping OpenCode services...');
+        if (webProcess) {
+            webProcess.kill('SIGTERM');
+            await new Promise(resolve => {
+                webProcess?.on('exit', () => resolve());
+                setTimeout(() => {
+                    webProcess?.kill('SIGKILL');
+                    resolve();
+                }, 3000);
+            });
+            webProcess = null;
+        }
+        if (isStarted) {
+            await killProcessOnPort(actualWebPort, config.hostname);
+        }
+        isStarted = false;
+        startPromise = null;
+    }
+    /**
+     * 处理上下文 API 请求
+     */
+    function handleContextRequest(req, res) {
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        if (req.method === 'GET') {
+            res.writeHead(200);
+            res.end(JSON.stringify(pageContext));
+            return;
+        }
+        if (req.method === 'DELETE') {
+            pageContext.selectedElements = [];
+            log('Selected elements cleared');
+            res.writeHead(200);
+            res.end(JSON.stringify({ success: true }));
+            return;
+        }
+        if (req.method === 'POST') {
+            let body = '';
+            req.on('data', chunk => body += chunk);
+            req.on('end', () => {
+                try {
+                    const data = JSON.parse(body);
+                    pageContext = {
+                        url: data.url || '',
+                        title: data.title || '',
+                        selectedElements: data.selectedElements || [],
+                    };
+                    log(`Context updated: ${pageContext.url}`, data.selectedElements?.length ? `elements: ${data.selectedElements.length}` : '');
+                    res.writeHead(200);
+                    res.end(JSON.stringify({ success: true }));
+                }
+                catch {
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+            });
+            return;
+        }
+        res.writeHead(405);
+        res.end(JSON.stringify({ error: 'Method not allowed' }));
+    }
+    return {
+        name: 'vite-plugin-opencode',
+        async configureServer(server) {
+            if (!config.enabled)
+                return;
+            const vitePort = server.config.server.port || 5173;
+            const viteHost = server.config.server.host || 'localhost';
+            const viteOrigin = `http://${viteHost}:${vitePort}`;
+            const contextApiUrl = `http://${viteHost}:${vitePort}${CONTEXT_API_PATH}`;
+            if (!config.lazy) {
+                await startServices([viteOrigin], contextApiUrl);
+            }
+            server.middlewares.use(WIDGET_SCRIPT_PATH, async (_req, res) => {
+                if (config.lazy && !isStarted) {
+                    await startServices([viteOrigin], contextApiUrl);
+                }
+                const widgetPath = path.join(__dirname, 'client.js');
+                if (fs.existsSync(widgetPath)) {
+                    res.setHeader('Content-Type', 'application/javascript');
+                    res.setHeader('Access-Control-Allow-Origin', '*');
+                    fs.createReadStream(widgetPath).pipe(res);
+                }
+                else {
+                    res.writeHead(404);
+                    res.end('Widget script not found');
+                }
+            });
+            server.middlewares.use(CONTEXT_API_PATH, async (req, res) => {
+                if (config.lazy && !isStarted) {
+                    await startServices([viteOrigin], contextApiUrl);
+                }
+                handleContextRequest(req, res);
+            });
+            server.middlewares.use(START_API_PATH, async (_req, res) => {
+                res.setHeader('Content-Type', 'application/json');
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                if (config.lazy && !isStarted) {
+                    try {
+                        await startServices([viteOrigin], contextApiUrl);
+                        res.writeHead(200);
+                        res.end(JSON.stringify({ success: true, sessionUrl }));
+                    }
+                    catch (e) {
+                        res.writeHead(500);
+                        res.end(JSON.stringify({ error: String(e) }));
+                    }
+                }
+                else {
+                    res.writeHead(200);
+                    res.end(JSON.stringify({ success: true, sessionUrl }));
+                }
+            });
+            server.middlewares.use(SESSIONS_API_PATH, async (req, res) => {
+                res.setHeader('Content-Type', 'application/json');
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(200);
+                    res.end();
+                    return;
+                }
+                if (config.lazy && !isStarted) {
+                    await startServices([viteOrigin], contextApiUrl);
+                }
+                try {
+                    if (req.method === 'GET') {
+                        const sessions = await getSessions();
+                        res.writeHead(200);
+                        res.end(JSON.stringify(sessions));
+                    }
+                    else if (req.method === 'POST') {
+                        const newSession = await createSession();
+                        res.writeHead(200);
+                        res.end(JSON.stringify(newSession));
+                    }
+                    else if (req.method === 'DELETE') {
+                        const url = new URL(req.url || '', `http://${req.headers.host}`);
+                        const sessionId = url.searchParams.get('id');
+                        if (!sessionId) {
+                            res.writeHead(400);
+                            res.end(JSON.stringify({ error: 'Session ID is required' }));
+                            return;
+                        }
+                        await deleteSession(sessionId);
+                        res.writeHead(200);
+                        res.end(JSON.stringify({ success: true }));
+                    }
+                    else {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: 'Method not allowed' }));
+                    }
+                }
+                catch (e) {
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: String(e) }));
+                }
+            });
+            server.httpServer?.on('close', stopServices);
+            const cleanup = async () => {
+                await stopServices();
+                process.exit(0);
+            };
+            process.on('SIGINT', cleanup);
+            process.on('SIGTERM', cleanup);
+            process.on('exit', () => {
+                webProcess?.kill('SIGKILL');
+            });
+        },
+        transformIndexHtml(html) {
+            const widget = injectWidget({
+                webUrl: `http://${config.hostname}:${actualWebPort}`,
+                serverUrl: `http://${config.hostname}:${actualWebPort}`,
+                position: config.position,
+                theme: config.theme,
+                open: config.open,
+                autoReload: config.autoReload,
+                cwd: process.cwd(),
+                sessionUrl: sessionUrl || undefined,
+                lazy: config.lazy,
+                hotkey: config.hotkey,
+            });
+            return html.replace('</body>', `${widget}</body>`);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Plugin, ViteDevServer } from 'vite'\nimport { spawn, ChildProcess } from 'child_process'\nimport path from 'path'\nimport fs from 'fs'\nimport http from 'http'\nimport { startOpenCodeWeb } from './web'\nimport { injectWidget } from './injector'\nimport { checkOpenCodeInstalled, findAvailablePort, killProcessOnPort, checkOpenCodeProcess } from './utils'\nimport { OpenCodeOptions, SessionInfo, PageContext } from './types'\nimport {\n  DEFAULT_CONFIG,\n  DEFAULT_RETRIES,\n  RETRY_DELAY,\n  PROCESS_KILL_DELAY,\n  LOG_PREFIX,\n  WIDGET_SCRIPT_PATH,\n  CONTEXT_API_PATH,\n  START_API_PATH,\n  SESSIONS_API_PATH,\n} from './constants'\n\n/**\n * OpenCode Vite 插件\n * @param options - 插件配置选项\n * @returns Vite 插件实例\n * @example\n * ```ts\n * // vite.config.ts\n * import opencode from 'vite-plugin-opencode'\n *\n * export default {\n *   plugins: [\n *     opencode({\n *       webPort: 4097,\n *       position: 'bottom-right',\n *       theme: 'auto'\n *     })\n *   ]\n * }\n * ```\n */\nexport default function opencodePlugin(options: OpenCodeOptions = {}): Plugin {\n  let webProcess: ChildProcess | null = null\n  let sessionUrl: string | null = null\n  let actualWebPort: number = DEFAULT_CONFIG.webPort\n  let isStarted = false\n  let startPromise: Promise<void> | null = null\n  let pageContext: PageContext = { url: '', title: '' }\n\n  const config = { ...DEFAULT_CONFIG, ...options }\n\n  /**\n   * 输出日志（仅在 verbose 模式下）\n   */\n  function log(message: string, ...args: unknown[]): void {\n    if (config.verbose) {\n      console.log(`${LOG_PREFIX} ${message}`, ...args)\n    }\n  }\n\n  /**\n   * 输出错误日志\n   */\n  function logError(message: string, ...args: unknown[]): void {\n    console.error(`${LOG_PREFIX} ${message}`, ...args)\n  }\n\n  /**\n   * Base64 编码字符串\n   */\n  function base64Encode(str: string): string {\n    return Buffer.from(str).toString('base64')\n  }\n\n  /**\n   * 延迟执行\n   */\n  function sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms))\n  }\n\n  /**\n   * 创建 HTTP 请求 Promise\n   */\n  function createHttpRequest<T>(options: http.RequestOptions, body?: string): Promise<T> {\n    return new Promise((resolve, reject) => {\n      const req = http.request(options, (res) => {\n        let data = ''\n        res.on('data', chunk => data += chunk)\n        res.on('end', () => {\n          try {\n            resolve(JSON.parse(data))\n          } catch {\n            reject(new Error(`JSON parse error: ${data.substring(0, 100)}`))\n          }\n        })\n      })\n      req.on('error', reject)\n      if (body) req.write(body)\n      req.end()\n    })\n  }\n\n  /**\n   * 获取会话列表\n   */\n  async function getSessions(retries = DEFAULT_RETRIES): Promise<SessionInfo[]> {\n    let lastError: Error | null = null\n\n    for (let i = 0; i < retries; i++) {\n      try {\n        return await createHttpRequest<SessionInfo[]>({\n          hostname: config.hostname,\n          port: actualWebPort,\n          path: '/session',\n        })\n      } catch (e) {\n        lastError = e instanceof Error ? e : new Error(String(e))\n        if (i < retries - 1) await sleep(RETRY_DELAY)\n      }\n    }\n\n    throw lastError\n  }\n\n  /**\n   * 创建新会话\n   */\n  async function createSession(retries = DEFAULT_RETRIES): Promise<SessionInfo> {\n    let lastError: Error | null = null\n\n    for (let i = 0; i < retries; i++) {\n      try {\n        return await createHttpRequest<SessionInfo>({\n          hostname: config.hostname,\n          port: actualWebPort,\n          path: '/session',\n          method: 'POST',\n        })\n      } catch (e) {\n        lastError = e instanceof Error ? e : new Error(String(e))\n        if (i < retries - 1) await sleep(RETRY_DELAY)\n      }\n    }\n\n    throw lastError\n  }\n\n  /**\n   * 删除会话\n   */\n  async function deleteSession(sessionId: string, retries = DEFAULT_RETRIES): Promise<void> {\n    let lastError: Error | null = null\n\n    for (let i = 0; i < retries; i++) {\n      try {\n        await createHttpRequest<void>({\n          hostname: config.hostname,\n          port: actualWebPort,\n          path: `/session/${sessionId}`,\n          method: 'DELETE',\n        })\n        return\n      } catch (e) {\n        lastError = e instanceof Error ? e : new Error(String(e))\n        if (i < retries - 1) await sleep(RETRY_DELAY)\n      }\n    }\n\n    throw lastError\n  }\n\n  /**\n   * 获取或创建会话\n   */\n  async function getOrCreateSession(): Promise<string> {\n    const projectDir = process.cwd()\n    log('Getting sessions...')\n    const sessions = await getSessions()\n    log(`Found ${sessions.length} sessions`)\n\n    const matchingSession = sessions.find(s => s.directory === projectDir)\n\n    if (matchingSession) {\n      return `http://${config.hostname}:${actualWebPort}/${base64Encode(projectDir)}/session/${matchingSession.id}`\n    }\n\n    log('Creating new session...')\n    const newSession = await createSession()\n    return `http://${config.hostname}:${actualWebPort}/${base64Encode(projectDir)}/session/${newSession.id}`\n  }\n\n  /**\n   * 设置 OpenCode 插件\n   */\n  function setupOpenCodePlugin(): string {\n    const projectDir = process.cwd()\n    const cacheDir = path.join(projectDir, 'node_modules', '.cache', 'opencode')\n    const pluginsDir = path.join(cacheDir, 'plugins')\n\n    if (!fs.existsSync(pluginsDir)) {\n      fs.mkdirSync(pluginsDir, { recursive: true })\n    }\n\n    const pluginSourcePath = path.join(__dirname, 'plugins', 'page-context.js')\n    const pluginTargetPath = path.join(pluginsDir, 'page-context.js')\n\n    if (fs.existsSync(pluginSourcePath)) {\n      fs.copyFileSync(pluginSourcePath, pluginTargetPath)\n      log(`Plugin installed to ${pluginTargetPath}`)\n    } else {\n      console.warn(`${LOG_PREFIX} Plugin source not found: ${pluginSourcePath}`)\n    }\n\n    return cacheDir\n  }\n\n  /**\n   * 启动服务\n   */\n  async function startServices(corsOrigins?: string[], contextApiUrl?: string): Promise<void> {\n    if (isStarted) return\n    if (startPromise) return startPromise\n\n    startPromise = (async () => {\n      log('Starting OpenCode services...')\n\n      if (!await checkOpenCodeInstalled()) {\n        logError(`OpenCode is not installed!\n\nPlease install OpenCode first:\n\n  # Using Homebrew (macOS)\n  brew install opencode-ai/tap/opencode\n\n  # Or using the install script\n  curl -fsSL https://opencode.ai/install | bash\n        `)\n        return\n      }\n\n      actualWebPort = await findAvailablePort(config.webPort, config.hostname)\n      if (actualWebPort !== config.webPort) {\n        log(`Port ${config.webPort} is in use, using ${actualWebPort} instead`)\n      }\n\n      const existingProcess = await checkOpenCodeProcess(actualWebPort)\n      if (existingProcess) {\n        log(`Found existing OpenCode process on port ${actualWebPort}`)\n      } else {\n        const killed = await killProcessOnPort(actualWebPort, config.hostname)\n        if (killed) {\n          log(`Killed stale process on port ${actualWebPort}`)\n          await sleep(PROCESS_KILL_DELAY)\n        }\n      }\n\n      const configDir = setupOpenCodePlugin()\n\n      if (!existingProcess) {\n        webProcess = await startOpenCodeWeb({\n          port: actualWebPort,\n          hostname: config.hostname,\n          serverUrl: '',\n          cwd: process.cwd(),\n          configDir,\n          corsOrigins,\n          contextApiUrl,\n        })\n        log(`OpenCode Web started at http://${config.hostname}:${actualWebPort}`)\n      }\n\n      try {\n        sessionUrl = await getOrCreateSession()\n        log(`Session URL: ${sessionUrl}`)\n      } catch (e) {\n        console.warn(`${LOG_PREFIX} Failed to get/create session:`, e)\n      }\n\n      isStarted = true\n    })()\n\n    return startPromise\n  }\n\n  /**\n   * 停止服务\n   */\n  async function stopServices(): Promise<void> {\n    log('Stopping OpenCode services...')\n    \n    if (webProcess) {\n      webProcess.kill('SIGTERM')\n      await new Promise<void>(resolve => {\n        webProcess?.on('exit', () => resolve())\n        setTimeout(() => {\n          webProcess?.kill('SIGKILL')\n          resolve()\n        }, 3000)\n      })\n      webProcess = null\n    }\n    \n    if (isStarted) {\n      await killProcessOnPort(actualWebPort, config.hostname)\n    }\n    \n    isStarted = false\n    startPromise = null\n  }\n\n  /**\n   * 处理上下文 API 请求\n   */\n  function handleContextRequest(req: http.IncomingMessage, res: http.ServerResponse): void {\n    res.setHeader('Content-Type', 'application/json')\n    res.setHeader('Access-Control-Allow-Origin', '*')\n    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS')\n    res.setHeader('Access-Control-Allow-Headers', 'Content-Type')\n\n    if (req.method === 'OPTIONS') {\n      res.writeHead(200)\n      res.end()\n      return\n    }\n\n    if (req.method === 'GET') {\n      res.writeHead(200)\n      res.end(JSON.stringify(pageContext))\n      return\n    }\n\n    if (req.method === 'DELETE') {\n      pageContext.selectedElements = []\n      log('Selected elements cleared')\n      res.writeHead(200)\n      res.end(JSON.stringify({ success: true }))\n      return\n    }\n\n    if (req.method === 'POST') {\n      let body = ''\n      req.on('data', chunk => body += chunk)\n      req.on('end', () => {\n        try {\n          const data = JSON.parse(body)\n          pageContext = {\n            url: data.url || '',\n            title: data.title || '',\n            selectedElements: data.selectedElements || [],\n          }\n          log(`Context updated: ${pageContext.url}`, data.selectedElements?.length ? `elements: ${data.selectedElements.length}` : '')\n          res.writeHead(200)\n          res.end(JSON.stringify({ success: true }))\n        } catch {\n          res.writeHead(400)\n          res.end(JSON.stringify({ error: 'Invalid JSON' }))\n        }\n      })\n      return\n    }\n\n    res.writeHead(405)\n    res.end(JSON.stringify({ error: 'Method not allowed' }))\n  }\n\n  return {\n    name: 'vite-plugin-opencode',\n\n    async configureServer(server: ViteDevServer) {\n      if (!config.enabled) return\n\n      const vitePort = server.config.server.port || 5173\n      const viteHost = server.config.server.host || 'localhost'\n      const viteOrigin = `http://${viteHost}:${vitePort}`\n      const contextApiUrl = `http://${viteHost}:${vitePort}${CONTEXT_API_PATH}`\n\n      if (!config.lazy) {\n        await startServices([viteOrigin], contextApiUrl)\n      }\n\n      server.middlewares.use(WIDGET_SCRIPT_PATH, async (_req, res) => {\n        if (config.lazy && !isStarted) {\n          await startServices([viteOrigin], contextApiUrl)\n        }\n\n        const widgetPath = path.join(__dirname, 'client.js')\n        if (fs.existsSync(widgetPath)) {\n          res.setHeader('Content-Type', 'application/javascript')\n          res.setHeader('Access-Control-Allow-Origin', '*')\n          fs.createReadStream(widgetPath).pipe(res)\n        } else {\n          res.writeHead(404)\n          res.end('Widget script not found')\n        }\n      })\n\n      server.middlewares.use(CONTEXT_API_PATH, async (req, res) => {\n        if (config.lazy && !isStarted) {\n          await startServices([viteOrigin], contextApiUrl)\n        }\n        handleContextRequest(req as http.IncomingMessage, res)\n      })\n\n      server.middlewares.use(START_API_PATH, async (_req, res) => {\n        res.setHeader('Content-Type', 'application/json')\n        res.setHeader('Access-Control-Allow-Origin', '*')\n\n        if (config.lazy && !isStarted) {\n          try {\n            await startServices([viteOrigin], contextApiUrl)\n            res.writeHead(200)\n            res.end(JSON.stringify({ success: true, sessionUrl }))\n          } catch (e) {\n            res.writeHead(500)\n            res.end(JSON.stringify({ error: String(e) }))\n          }\n        } else {\n          res.writeHead(200)\n          res.end(JSON.stringify({ success: true, sessionUrl }))\n        }\n      })\n\n      server.middlewares.use(SESSIONS_API_PATH, async (req, res) => {\n        res.setHeader('Content-Type', 'application/json')\n        res.setHeader('Access-Control-Allow-Origin', '*')\n        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS')\n        res.setHeader('Access-Control-Allow-Headers', 'Content-Type')\n\n        if (req.method === 'OPTIONS') {\n          res.writeHead(200)\n          res.end()\n          return\n        }\n\n        if (config.lazy && !isStarted) {\n          await startServices([viteOrigin], contextApiUrl)\n        }\n\n        try {\n          if (req.method === 'GET') {\n            const sessions = await getSessions()\n            res.writeHead(200)\n            res.end(JSON.stringify(sessions))\n          } else if (req.method === 'POST') {\n            const newSession = await createSession()\n            res.writeHead(200)\n            res.end(JSON.stringify(newSession))\n          } else if (req.method === 'DELETE') {\n            const url = new URL(req.url || '', `http://${req.headers.host}`)\n            const sessionId = url.searchParams.get('id')\n            \n            if (!sessionId) {\n              res.writeHead(400)\n              res.end(JSON.stringify({ error: 'Session ID is required' }))\n              return\n            }\n            \n            await deleteSession(sessionId)\n            res.writeHead(200)\n            res.end(JSON.stringify({ success: true }))\n          } else {\n            res.writeHead(405)\n            res.end(JSON.stringify({ error: 'Method not allowed' }))\n          }\n        } catch (e) {\n          res.writeHead(500)\n          res.end(JSON.stringify({ error: String(e) }))\n        }\n      })\n\n      server.httpServer?.on('close', stopServices)\n      \n      const cleanup = async () => {\n        await stopServices()\n        process.exit(0)\n      }\n      \n      process.on('SIGINT', cleanup)\n      process.on('SIGTERM', cleanup)\n      process.on('exit', () => {\n        webProcess?.kill('SIGKILL')\n      })\n    },\n\n    transformIndexHtml(html) {\n      const widget = injectWidget({\n        webUrl: `http://${config.hostname}:${actualWebPort}`,\n        serverUrl: `http://${config.hostname}:${actualWebPort}`,\n        position: config.position,\n        theme: config.theme,\n        open: config.open,\n        autoReload: config.autoReload,\n        cwd: process.cwd(),\n        sessionUrl: sessionUrl || undefined,\n        lazy: config.lazy,\n        hotkey: config.hotkey,\n      })\n      return html.replace('</body>', `${widget}</body>`)\n    },\n  }\n}\n"]}

package/dist/injector.d.ts

@@ -0,0 +1,20 @@
+import { WidgetOptions } from './types';
+/**
+ * 生成挂件注入脚本标签
+ * @param options - 挂件配置选项
+ * @returns HTML 脚本标签字符串
+ * @example
+ * ```ts
+ * const widget = injectWidget({
+ *   webUrl: 'http://127.0.0.1:4097',
+ *   serverUrl: 'http://127.0.0.1:4097',
+ *   position: 'bottom-right',
+ *   theme: 'auto',
+ *   open: false,
+ *   autoReload: true,
+ *   cwd: process.cwd()
+ * })
+ * // 返回: '<script src="/__opencode_widget__.js" data-opencode-config="..."></script>'
+ * ```
+ */
+export declare function injectWidget(options: WidgetOptions): string;

package/dist/injector.js

@@ -0,0 +1,24 @@
+import { WIDGET_SCRIPT_PATH, CONFIG_DATA_ATTR } from './constants';
+/**
+ * 生成挂件注入脚本标签
+ * @param options - 挂件配置选项
+ * @returns HTML 脚本标签字符串
+ * @example
+ * ```ts
+ * const widget = injectWidget({
+ *   webUrl: 'http://127.0.0.1:4097',
+ *   serverUrl: 'http://127.0.0.1:4097',
+ *   position: 'bottom-right',
+ *   theme: 'auto',
+ *   open: false,
+ *   autoReload: true,
+ *   cwd: process.cwd()
+ * })
+ * // 返回: '<script src="/__opencode_widget__.js" data-opencode-config="..."></script>'
+ * ```
+ */
+export function injectWidget(options) {
+    const configBase64 = Buffer.from(JSON.stringify(options)).toString('base64');
+    return `<script src="${WIDGET_SCRIPT_PATH}" ${CONFIG_DATA_ATTR}="${configBase64}"></script>`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5qZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGtCQUFrQixFQUFFLGdCQUFnQixFQUFFLE1BQU0sYUFBYSxDQUFBO0FBRWxFOzs7Ozs7Ozs7Ozs7Ozs7OztHQWlCRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQUMsT0FBc0I7SUFDakQsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFBO0lBQzVFLE9BQU8sZ0JBQWdCLGtCQUFrQixLQUFLLGdCQUFnQixLQUFLLFlBQVksYUFBYSxDQUFBO0FBQzlGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXaWRnZXRPcHRpb25zIH0gZnJvbSAnLi90eXBlcydcbmltcG9ydCB7IFdJREdFVF9TQ1JJUFRfUEFUSCwgQ09ORklHX0RBVEFfQVRUUiB9IGZyb20gJy4vY29uc3RhbnRzJ1xuXG4vKipcbiAqIOeUn+aIkOaMguS7tuazqOWFpeiEmuacrOagh+etvlxuICogQHBhcmFtIG9wdGlvbnMgLSDmjILku7bphY3nva7pgInpoblcbiAqIEByZXR1cm5zIEhUTUwg6ISa5pys5qCH562+5a2X56ym5LiyXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIGNvbnN0IHdpZGdldCA9IGluamVjdFdpZGdldCh7XG4gKiAgIHdlYlVybDogJ2h0dHA6Ly8xMjcuMC4wLjE6NDA5NycsXG4gKiAgIHNlcnZlclVybDogJ2h0dHA6Ly8xMjcuMC4wLjE6NDA5NycsXG4gKiAgIHBvc2l0aW9uOiAnYm90dG9tLXJpZ2h0JyxcbiAqICAgdGhlbWU6ICdhdXRvJyxcbiAqICAgb3BlbjogZmFsc2UsXG4gKiAgIGF1dG9SZWxvYWQ6IHRydWUsXG4gKiAgIGN3ZDogcHJvY2Vzcy5jd2QoKVxuICogfSlcbiAqIC8vIOi/lOWbnjogJzxzY3JpcHQgc3JjPVwiL19fb3BlbmNvZGVfd2lkZ2V0X18uanNcIiBkYXRhLW9wZW5jb2RlLWNvbmZpZz1cIi4uLlwiPjwvc2NyaXB0PidcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0V2lkZ2V0KG9wdGlvbnM6IFdpZGdldE9wdGlvbnMpOiBzdHJpbmcge1xuICBjb25zdCBjb25maWdCYXNlNjQgPSBCdWZmZXIuZnJvbShKU09OLnN0cmluZ2lmeShvcHRpb25zKSkudG9TdHJpbmcoJ2Jhc2U2NCcpXG4gIHJldHVybiBgPHNjcmlwdCBzcmM9XCIke1dJREdFVF9TQ1JJUFRfUEFUSH1cIiAke0NPTkZJR19EQVRBX0FUVFJ9PVwiJHtjb25maWdCYXNlNjR9XCI+PC9zY3JpcHQ+YFxufVxuIl19

package/dist/plugins/page-context.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview OpenCode 页面上下文插件
+ * @description 用于将页面上下文信息注入到 AI 对话中
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+/**
+ * OpenCode 页面上下文插件
+ * @returns 插件钩子
+ * @example
+ * ```ts
+ * // 在 opencode 配置中使用
+ * import { PageContextPlugin } from './plugins/page-context'
+ *
+ * export default {
+ *   plugins: [PageContextPlugin]
+ * }
+ * ```
+ */
+export declare const PageContextPlugin: Plugin;
+export default PageContextPlugin;