vite-plugin-opencode-assistant 1.0.0

package/dist/plugins/page-context.js

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview OpenCode 页面上下文插件
+ * @description 用于将页面上下文信息注入到 AI 对话中
+ */
+/** 最大文本长度 */
+const MAX_TEXT_LENGTH = 10000;
+/** 上下文标记 */
+const CONTEXT_MARKER = '__OPENCODE_CONTEXT__';
+/**
+ * OpenCode 页面上下文插件
+ * @returns 插件钩子
+ * @example
+ * ```ts
+ * // 在 opencode 配置中使用
+ * import { PageContextPlugin } from './plugins/page-context'
+ *
+ * export default {
+ *   plugins: [PageContextPlugin]
+ * }
+ * ```
+ */
+export const PageContextPlugin = async () => {
+    const contextApiUrl = process.env.OPENCODE_CONTEXT_API_URL;
+    if (!contextApiUrl) {
+        console.warn('OPENCODE_CONTEXT_API_URL is not set, page context plugin will not work');
+        return {};
+    }
+    const apiUrl = contextApiUrl;
+    /**
+     * 获取页面上下文
+     * @returns 页面上下文数据，获取失败时返回 null
+     */
+    async function getPageContext() {
+        try {
+            const response = await fetch(apiUrl);
+            const data = await response.json();
+            return {
+                url: data.url || "",
+                title: data.title || "",
+                selectedElements: data.selectedElements
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 清除选中的元素
+     */
+    async function clearSelectedElements() {
+        try {
+            await fetch(apiUrl, { method: 'DELETE' });
+        }
+        catch {
+            // 忽略错误
+        }
+    }
+    /**
+     * 格式化选中元素信息
+     * @param element - 选中的元素
+     * @returns 格式化后的元素信息字符串
+     */
+    function formatSelectedElement(element) {
+        const parts = [];
+        if (element.filePath) {
+            let location = `文件: ${element.filePath}`;
+            if (element.line) {
+                location += `:${element.line}`;
+                if (element.column) {
+                    location += `:${element.column}`;
+                }
+            }
+            parts.push(location);
+        }
+        if (element.innerText?.trim()) {
+            const text = element.innerText.trim().substring(0, MAX_TEXT_LENGTH);
+            const suffix = element.innerText.length > MAX_TEXT_LENGTH ? '...' : '';
+            parts.push(`节点文本: "${text}${suffix}"`);
+        }
+        return parts.join('\n') + '\n';
+    }
+    /**
+     * 构建上下文前缀
+     * @param context - 页面上下文
+     * @returns 上下文前缀字符串
+     */
+    function buildContextPrefix(context) {
+        let prefix = `我现在正在浏览这个页面：${context.url}\n\n`;
+        if (context.selectedElements?.length) {
+            prefix += `帮我找到以下节点，一定要精确到具体的节点：\n\n`;
+            context.selectedElements.forEach((element) => {
+                prefix += formatSelectedElement(element) + "\n";
+            });
+        }
+        prefix += `请根据以上信息，完成以下任务：\n`;
+        prefix += `\n`;
+        return prefix;
+    }
+    return {
+        "experimental.chat.messages.transform": async (_input, output) => {
+            const context = await getPageContext();
+            if (!context?.url)
+                return;
+            const lastUserMsg = [...output.messages].reverse().find(m => m.info.role === "user");
+            if (!lastUserMsg)
+                return;
+            const textPart = lastUserMsg.parts.find(p => p.type === "text");
+            if (!textPart || !("text" in textPart))
+                return;
+            if (textPart.text.includes(CONTEXT_MARKER))
+                return;
+            const prefix = buildContextPrefix(context);
+            textPart.text = prefix + textPart.text;
+            if (context.selectedElements?.length) {
+                await clearSelectedElements();
+            }
+        }
+    };
+};
+export default PageContextPlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"page-context.js","sourceRoot":"","sources":["../../src/plugins/page-context.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @fileoverview OpenCode 页面上下文插件\n * @description 用于将页面上下文信息注入到 AI 对话中\n */\n\nimport type { Plugin, Hooks } from \"@opencode-ai/plugin\"\n\n/** 最大文本长度 */\nconst MAX_TEXT_LENGTH = 10000\n\n/** 上下文标记 */\nconst CONTEXT_MARKER = '__OPENCODE_CONTEXT__'\n\n/**\n * 选中的元素信息\n */\ninterface SelectedElement {\n  /** 文件路径 */\n  filePath: string | null\n  /** 行号 */\n  line: number | null\n  /** 列号 */\n  column: number | null\n  /** 元素内部文本 */\n  innerText: string\n}\n\n/**\n * 页面上下文数据\n */\ninterface PageContextData {\n  /** 当前页面 URL */\n  url: string\n  /** 当前页面标题 */\n  title: string\n  /** 选中的元素列表 */\n  selectedElements?: SelectedElement[]\n}\n\n/**\n * OpenCode 页面上下文插件\n * @returns 插件钩子\n * @example\n * ```ts\n * // 在 opencode 配置中使用\n * import { PageContextPlugin } from './plugins/page-context'\n *\n * export default {\n *   plugins: [PageContextPlugin]\n * }\n * ```\n */\nexport const PageContextPlugin: Plugin = async (): Promise<Hooks> => {\n  const contextApiUrl = process.env.OPENCODE_CONTEXT_API_URL\n\n  if (!contextApiUrl) {\n    console.warn('OPENCODE_CONTEXT_API_URL is not set, page context plugin will not work')\n    return {}\n  }\n\n  const apiUrl = contextApiUrl as string\n\n  /**\n   * 获取页面上下文\n   * @returns 页面上下文数据，获取失败时返回 null\n   */\n  async function getPageContext(): Promise<PageContextData | null> {\n    try {\n      const response = await fetch(apiUrl)\n      const data = await response.json() as PageContextData\n      return {\n        url: data.url || \"\",\n        title: data.title || \"\",\n        selectedElements: data.selectedElements\n      }\n    } catch {\n      return null\n    }\n  }\n\n  /**\n   * 清除选中的元素\n   */\n  async function clearSelectedElements(): Promise<void> {\n    try {\n      await fetch(apiUrl, { method: 'DELETE' })\n    } catch {\n      // 忽略错误\n    }\n  }\n\n  /**\n   * 格式化选中元素信息\n   * @param element - 选中的元素\n   * @returns 格式化后的元素信息字符串\n   */\n  function formatSelectedElement(element: SelectedElement): string {\n    const parts: string[] = []\n\n    if (element.filePath) {\n      let location = `文件: ${element.filePath}`\n      if (element.line) {\n        location += `:${element.line}`\n        if (element.column) {\n          location += `:${element.column}`\n        }\n      }\n      parts.push(location)\n    }\n\n    if (element.innerText?.trim()) {\n      const text = element.innerText.trim().substring(0, MAX_TEXT_LENGTH)\n      const suffix = element.innerText.length > MAX_TEXT_LENGTH ? '...' : ''\n      parts.push(`节点文本: \"${text}${suffix}\"`)\n    }\n\n    return parts.join('\\n') + '\\n'\n  }\n\n  /**\n   * 构建上下文前缀\n   * @param context - 页面上下文\n   * @returns 上下文前缀字符串\n   */\n  function buildContextPrefix(context: PageContextData): string {\n    let prefix = `我现在正在浏览这个页面：${context.url}\\n\\n`\n\n    if (context.selectedElements?.length) {\n      prefix += `帮我找到以下节点，一定要精确到具体的节点：\\n\\n`\n      context.selectedElements.forEach((element) => {\n        prefix += formatSelectedElement(element) + \"\\n\"\n      })\n    }\n\n    prefix += `请根据以上信息，完成以下任务：\\n`\n\n    prefix += `\\n`\n    return prefix\n  }\n\n  return {\n    \"experimental.chat.messages.transform\": async (_input, output) => {\n      const context = await getPageContext()\n      \n      if (!context?.url) return\n\n      const lastUserMsg = [...output.messages].reverse().find(m => m.info.role === \"user\")\n      if (!lastUserMsg) return\n\n      const textPart = lastUserMsg.parts.find(p => p.type === \"text\")\n      if (!textPart || !(\"text\" in textPart)) return\n      \n      if (textPart.text.includes(CONTEXT_MARKER)) return\n\n      const prefix = buildContextPrefix(context)\n      textPart.text = prefix + textPart.text\n\n      if (context.selectedElements?.length) {\n        await clearSelectedElements()\n      }\n    }\n  }\n}\n\nexport default PageContextPlugin\n"]}

package/dist/types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * OpenCode Vite 插件配置选项
+ */
+export interface OpenCodeOptions {
+    /** 是否启用插件，默认 true */
+    enabled?: boolean;
+    /** @deprecated 使用 webPort 代替 */
+    serverPort?: number;
+    /** Web 服务端口，默认 4097 */
+    webPort?: number;
+    /** 服务主机名，默认 '127.0.0.1' */
+    hostname?: string;
+    /** 挂件位置，默认 'bottom-right' */
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** 主题模式，默认 'auto' */
+    theme?: 'light' | 'dark' | 'auto';
+    /** 是否自动打开面板，默认 false */
+    open?: boolean;
+    /** 是否自动重载，默认 true */
+    autoReload?: boolean;
+    /** 是否输出详细日志，默认 false */
+    verbose?: boolean;
+    /** 是否懒加载服务，默认 false */
+    lazy?: boolean;
+    /** 快捷键配置，默认 'ctrl+k' */
+    hotkey?: string;
+}
+/**
+ * OpenCode Web 服务启动选项
+ */
+export interface WebOptions {
+    /** 服务端口 */
+    port: number;
+    /** 服务主机名 */
+    hostname: string;
+    /** 服务器 URL */
+    serverUrl: string;
+    /** 工作目录 */
+    cwd: string;
+    /** 配置目录路径 */
+    configDir?: string;
+    /** CORS 允许的源 */
+    corsOrigins?: string[];
+    /** 上下文 API URL */
+    contextApiUrl?: string;
+}
+/**
+ * 挂件注入配置选项
+ */
+export interface WidgetOptions {
+    /** Web 服务 URL */
+    webUrl: string;
+    /** 服务器 URL */
+    serverUrl: string;
+    /** 挂件位置 */
+    position: string;
+    /** 主题模式 */
+    theme: string;
+    /** 是否自动打开 */
+    open: boolean;
+    /** 是否自动重载 */
+    autoReload: boolean;
+    /** 工作目录 */
+    cwd: string;
+    /** 会话 URL */
+    sessionUrl?: string;
+    /** 是否懒加载 */
+    lazy?: boolean;
+    /** 快捷键配置 */
+    hotkey?: string;
+}
+/**
+ * OpenCode 会话信息
+ */
+export interface SessionInfo {
+    /** 会话 ID */
+    id: string;
+    /** 会话标识符 */
+    slug: string;
+    /** 项目 ID */
+    projectID: string;
+    /** 项目目录 */
+    directory: string;
+    /** 会话标题 */
+    title: string;
+    /** 版本号 */
+    version: string;
+    /** 代码变更统计 */
+    summary: {
+        /** 新增行数 */
+        additions: number;
+        /** 删除行数 */
+        deletions: number;
+        /** 修改文件数 */
+        files: number;
+    };
+    /** 时间信息 */
+    time: {
+        /** 创建时间戳 */
+        created: number;
+        /** 更新时间戳 */
+        updated: number;
+    };
+}
+/**
+ * 选中的元素信息
+ */
+export interface SelectedElement {
+    /** 文件路径 */
+    filePath: string | null;
+    /** 行号 */
+    line: number | null;
+    /** 列号 */
+    column: number | null;
+    /** 元素内部文本 */
+    innerText: string;
+    /** 元素描述（标签名+选择器） */
+    description?: string;
+}
+/**
+ * 页面上下文数据
+ */
+export interface PageContext {
+    /** 当前页面 URL */
+    url: string;
+    /** 当前页面标题 */
+    title: string;
+    /** 选中的元素列表 */
+    selectedElements?: SelectedElement[];
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 等待服务器就绪
+ * @param url - 服务器 URL
+ * @param timeout - 超时时间（毫秒），默认 10000
+ * @returns Promise，服务器就绪时 resolve
+ * @throws 超时后抛出错误
+ */
+export declare function waitForServer(url: string, timeout?: number): Promise<void>;
+/**
+ * 检查 OpenCode 是否已安装
+ * @returns 是否已安装
+ */
+export declare function checkOpenCodeInstalled(): Promise<boolean>;
+/**
+ * 检查端口是否可用
+ * @param port - 端口号
+ * @param hostname - 主机名，默认 '127.0.0.1'
+ * @returns 端口是否可用
+ */
+export declare function isPortAvailable(port: number, hostname?: string): Promise<boolean>;
+/**
+ * 查找可用端口
+ * @param startPort - 起始端口
+ * @param hostname - 主机名，默认 '127.0.0.1'
+ * @param maxTries - 最大尝试次数，默认 10
+ * @returns 可用的端口号
+ * @throws 找不到可用端口时抛出错误
+ */
+export declare function findAvailablePort(startPort: number, hostname?: string, maxTries?: number): Promise<number>;
+/**
+ * 终止占用指定端口的进程
+ * @param port - 端口号
+ * @param hostname - 主机名，默认 '127.0.0.1'
+ * @returns 是否成功终止进程
+ */
+export declare function killProcessOnPort(port: number, hostname?: string): Promise<boolean>;
+/**
+ * 检查 OpenCode 进程是否在运行
+ * @param port - 服务端口
+ * @returns 进程是否在运行
+ */
+export declare function checkOpenCodeProcess(port: number): Promise<boolean>;

package/dist/utils.js

@@ -0,0 +1,156 @@
+import http from 'http';
+import { spawn } from 'child_process';
+import net from 'net';
+import { DEFAULT_HOSTNAME, SERVER_CHECK_INTERVAL, HEALTH_CHECK_TIMEOUT, MAX_PORT_TRIES, } from './constants';
+/**
+ * 等待服务器就绪
+ * @param url - 服务器 URL
+ * @param timeout - 超时时间（毫秒），默认 10000
+ * @returns Promise，服务器就绪时 resolve
+ * @throws 超时后抛出错误
+ */
+export function waitForServer(url, timeout = 10000) {
+    return new Promise((resolve, reject) => {
+        const startTime = Date.now();
+        const check = () => {
+            const req = http.get(url, (res) => {
+                if (res.statusCode && res.statusCode < 500) {
+                    resolve();
+                }
+                else {
+                    retryOrReject();
+                }
+            });
+            req.on('error', retryOrReject);
+        };
+        const retryOrReject = () => {
+            if (Date.now() - startTime < timeout) {
+                setTimeout(check, SERVER_CHECK_INTERVAL);
+            }
+            else {
+                reject(new Error(`Server not ready after ${timeout}ms`));
+            }
+        };
+        check();
+    });
+}
+/**
+ * 检查 OpenCode 是否已安装
+ * @returns 是否已安装
+ */
+export async function checkOpenCodeInstalled() {
+    return new Promise((resolve) => {
+        const proc = spawn('opencode', ['--version'], { stdio: 'ignore' });
+        proc.on('close', (code) => resolve(code === 0));
+        proc.on('error', () => resolve(false));
+    });
+}
+/**
+ * 检查端口是否可用
+ * @param port - 端口号
+ * @param hostname - 主机名，默认 '127.0.0.1'
+ * @returns 端口是否可用
+ */
+export async function isPortAvailable(port, hostname = DEFAULT_HOSTNAME) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', () => resolve(false));
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port, hostname);
+    });
+}
+/**
+ * 查找可用端口
+ * @param startPort - 起始端口
+ * @param hostname - 主机名，默认 '127.0.0.1'
+ * @param maxTries - 最大尝试次数，默认 10
+ * @returns 可用的端口号
+ * @throws 找不到可用端口时抛出错误
+ */
+export async function findAvailablePort(startPort, hostname = DEFAULT_HOSTNAME, maxTries = MAX_PORT_TRIES) {
+    for (let port = startPort; port < startPort + maxTries; port++) {
+        if (await isPortAvailable(port, hostname)) {
+            return port;
+        }
+    }
+    throw new Error(`No available port found after ${maxTries} tries starting from ${startPort}`);
+}
+/**
+ * 终止占用指定端口的进程
+ * @param port - 端口号
+ * @param hostname - 主机名，默认 '127.0.0.1'
+ * @returns 是否成功终止进程
+ */
+export async function killProcessOnPort(port, hostname = DEFAULT_HOSTNAME) {
+    return new Promise((resolve) => {
+        if (process.platform === 'win32') {
+            killProcessOnWindows(port, resolve);
+        }
+        else {
+            killProcessOnUnix(port, resolve);
+        }
+    });
+}
+/**
+ * 在 Windows 上终止占用端口的进程
+ */
+function killProcessOnWindows(port, resolve) {
+    const proc = spawn('cmd', ['/c', `netstat -ano | findstr :${port}`], { stdio: 'pipe' });
+    let output = '';
+    proc.stdout?.on('data', (data) => {
+        output += data.toString();
+    });
+    proc.on('close', () => {
+        const match = output.match(/LISTENING\s+(\d+)/);
+        if (match) {
+            spawn('taskkill', ['/F', '/PID', match[1]], { stdio: 'ignore' })
+                .on('close', (code) => resolve(code === 0));
+        }
+        else {
+            resolve(false);
+        }
+    });
+}
+/**
+ * 在 Unix 系统上终止占用端口的进程
+ */
+function killProcessOnUnix(port, resolve) {
+    const proc = spawn('lsof', ['-ti', `tcp:${port}`, '-sTCP:LISTEN'], { stdio: 'pipe' });
+    let output = '';
+    proc.stdout?.on('data', (data) => {
+        output += data.toString();
+    });
+    proc.on('close', () => {
+        const pids = output.trim().split('\n').filter(Boolean);
+        if (pids.length > 0) {
+            const killProc = spawn('kill', ['-9', ...pids], { stdio: 'ignore' });
+            killProc.on('close', (code) => resolve(code === 0));
+        }
+        else {
+            resolve(false);
+        }
+    });
+}
+/**
+ * 检查 OpenCode 进程是否在运行
+ * @param port - 服务端口
+ * @returns 进程是否在运行
+ */
+export async function checkOpenCodeProcess(port) {
+    return new Promise((resolve) => {
+        const req = http.get({
+            hostname: DEFAULT_HOSTNAME,
+            port,
+            path: '/health',
+            timeout: HEALTH_CHECK_TIMEOUT,
+        }, (res) => {
+            resolve(res.statusCode === 200);
+        });
+        req.on('error', () => resolve(false));
+        req.end();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import http from 'http'\nimport { spawn } from 'child_process'\nimport net from 'net'\nimport {\n  DEFAULT_HOSTNAME,\n  SERVER_CHECK_INTERVAL,\n  HEALTH_CHECK_TIMEOUT,\n  MAX_PORT_TRIES,\n} from './constants'\n\n/**\n * 等待服务器就绪\n * @param url - 服务器 URL\n * @param timeout - 超时时间（毫秒），默认 10000\n * @returns Promise，服务器就绪时 resolve\n * @throws 超时后抛出错误\n */\nexport function waitForServer(url: string, timeout = 10000): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const startTime = Date.now()\n\n    const check = (): void => {\n      const req = http.get(url, (res) => {\n        if (res.statusCode && res.statusCode < 500) {\n          resolve()\n        } else {\n          retryOrReject()\n        }\n      })\n\n      req.on('error', retryOrReject)\n    }\n\n    const retryOrReject = (): void => {\n      if (Date.now() - startTime < timeout) {\n        setTimeout(check, SERVER_CHECK_INTERVAL)\n      } else {\n        reject(new Error(`Server not ready after ${timeout}ms`))\n      }\n    }\n\n    check()\n  })\n}\n\n/**\n * 检查 OpenCode 是否已安装\n * @returns 是否已安装\n */\nexport async function checkOpenCodeInstalled(): Promise<boolean> {\n  return new Promise((resolve) => {\n    const proc = spawn('opencode', ['--version'], { stdio: 'ignore' })\n    proc.on('close', (code) => resolve(code === 0))\n    proc.on('error', () => resolve(false))\n  })\n}\n\n/**\n * 检查端口是否可用\n * @param port - 端口号\n * @param hostname - 主机名，默认 '127.0.0.1'\n * @returns 端口是否可用\n */\nexport async function isPortAvailable(port: number, hostname = DEFAULT_HOSTNAME): Promise<boolean> {\n  return new Promise((resolve) => {\n    const server = net.createServer()\n    server.once('error', () => resolve(false))\n    server.once('listening', () => {\n      server.close()\n      resolve(true)\n    })\n    server.listen(port, hostname)\n  })\n}\n\n/**\n * 查找可用端口\n * @param startPort - 起始端口\n * @param hostname - 主机名，默认 '127.0.0.1'\n * @param maxTries - 最大尝试次数，默认 10\n * @returns 可用的端口号\n * @throws 找不到可用端口时抛出错误\n */\nexport async function findAvailablePort(\n  startPort: number,\n  hostname = DEFAULT_HOSTNAME,\n  maxTries = MAX_PORT_TRIES\n): Promise<number> {\n  for (let port = startPort; port < startPort + maxTries; port++) {\n    if (await isPortAvailable(port, hostname)) {\n      return port\n    }\n  }\n  throw new Error(`No available port found after ${maxTries} tries starting from ${startPort}`)\n}\n\n/**\n * 终止占用指定端口的进程\n * @param port - 端口号\n * @param hostname - 主机名，默认 '127.0.0.1'\n * @returns 是否成功终止进程\n */\nexport async function killProcessOnPort(port: number, hostname = DEFAULT_HOSTNAME): Promise<boolean> {\n  return new Promise((resolve) => {\n    if (process.platform === 'win32') {\n      killProcessOnWindows(port, resolve)\n    } else {\n      killProcessOnUnix(port, resolve)\n    }\n  })\n}\n\n/**\n * 在 Windows 上终止占用端口的进程\n */\nfunction killProcessOnWindows(port: number, resolve: (value: boolean) => void): void {\n  const proc = spawn('cmd', ['/c', `netstat -ano | findstr :${port}`], { stdio: 'pipe' })\n  let output = ''\n\n  proc.stdout?.on('data', (data) => {\n    output += data.toString()\n  })\n\n  proc.on('close', () => {\n    const match = output.match(/LISTENING\\s+(\\d+)/)\n    if (match) {\n      spawn('taskkill', ['/F', '/PID', match[1]], { stdio: 'ignore' })\n        .on('close', (code) => resolve(code === 0))\n    } else {\n      resolve(false)\n    }\n  })\n}\n\n/**\n * 在 Unix 系统上终止占用端口的进程\n */\nfunction killProcessOnUnix(port: number, resolve: (value: boolean) => void): void {\n  const proc = spawn('lsof', ['-ti', `tcp:${port}`, '-sTCP:LISTEN'], { stdio: 'pipe' })\n  let output = ''\n\n  proc.stdout?.on('data', (data) => {\n    output += data.toString()\n  })\n\n  proc.on('close', () => {\n    const pids = output.trim().split('\\n').filter(Boolean)\n    if (pids.length > 0) {\n      const killProc = spawn('kill', ['-9', ...pids], { stdio: 'ignore' })\n      killProc.on('close', (code) => resolve(code === 0))\n    } else {\n      resolve(false)\n    }\n  })\n}\n\n/**\n * 检查 OpenCode 进程是否在运行\n * @param port - 服务端口\n * @returns 进程是否在运行\n */\nexport async function checkOpenCodeProcess(port: number): Promise<boolean> {\n  return new Promise((resolve) => {\n    const req = http.get({\n      hostname: DEFAULT_HOSTNAME,\n      port,\n      path: '/health',\n      timeout: HEALTH_CHECK_TIMEOUT,\n    }, (res) => {\n      resolve(res.statusCode === 200)\n    })\n    req.on('error', () => resolve(false))\n    req.end()\n  })\n}\n"]}

package/dist/web.d.ts

@@ -0,0 +1,18 @@
+import { ChildProcess } from 'child_process';
+import { WebOptions } from './types';
+/**
+ * 启动 OpenCode Web 服务
+ * @param options - Web 服务启动选项
+ * @returns 子进程实例
+ * @throws 服务启动超时时抛出错误
+ * @example
+ * ```ts
+ * const proc = await startOpenCodeWeb({
+ *   port: 4097,
+ *   hostname: '127.0.0.1',
+ *   serverUrl: '',
+ *   cwd: process.cwd()
+ * })
+ * ```
+ */
+export declare function startOpenCodeWeb(options: WebOptions): Promise<ChildProcess>;

package/dist/web.js

@@ -0,0 +1,95 @@
+import { spawn } from 'child_process';
+import { waitForServer } from './utils';
+import { SERVER_START_TIMEOUT, LOG_PREFIX, } from './constants';
+import path from 'path';
+import fs from 'fs';
+/**
+ * 启动 OpenCode Web 服务
+ * @param options - Web 服务启动选项
+ * @returns 子进程实例
+ * @throws 服务启动超时时抛出错误
+ * @example
+ * ```ts
+ * const proc = await startOpenCodeWeb({
+ *   port: 4097,
+ *   hostname: '127.0.0.1',
+ *   serverUrl: '',
+ *   cwd: process.cwd()
+ * })
+ * ```
+ */
+export async function startOpenCodeWeb(options) {
+    const { port, hostname, cwd, configDir, corsOrigins, contextApiUrl } = options;
+    const stateDir = createStateDirectory(cwd);
+    const pluginPath = path.join(stateDir, 'plugins', 'page-context.js');
+    const env = buildProcessEnv(stateDir, configDir, contextApiUrl, pluginPath);
+    const args = [
+        'serve',
+        '--port', String(port),
+        '--hostname', hostname,
+    ];
+    if (corsOrigins && corsOrigins.length > 0) {
+        corsOrigins.forEach(origin => {
+            args.push('--cors', origin);
+        });
+    }
+    const proc = spawn('opencode', args, {
+        cwd,
+        stdio: 'pipe',
+        env,
+    });
+    setupProcessHandlers(proc, port, hostname);
+    await waitForServer(`http://${hostname}:${port}`, SERVER_START_TIMEOUT);
+    console.log(`\n\x1b[36m\x1b[1m${LOG_PREFIX}\x1b[0m ✨ OpenCode server started successfully\n`);
+    return proc;
+}
+/**
+ * 创建状态目录
+ * @param cwd - 工作目录
+ * @returns 状态目录路径
+ */
+function createStateDirectory(cwd) {
+    const stateDir = path.join(cwd, 'node_modules', '.cache', 'opencode');
+    if (!fs.existsSync(stateDir)) {
+        fs.mkdirSync(stateDir, { recursive: true });
+    }
+    return stateDir;
+}
+/**
+ * 构建进程环境变量
+ * @param stateDir - 状态目录路径
+ * @param configDir - 配置目录路径
+ * @param contextApiUrl - 上下文 API URL
+ * @param pluginPath - 插件路径
+ * @returns 环境变量对象
+ */
+function buildProcessEnv(stateDir, configDir, contextApiUrl, pluginPath) {
+    const env = {
+        ...Object.fromEntries(Object.entries(process.env).filter(([, v]) => v !== undefined)),
+        XDG_STATE_HOME: stateDir,
+    };
+    if (configDir) {
+        env.OPENCODE_CONFIG_DIR = configDir;
+    }
+    if (contextApiUrl) {
+        env.OPENCODE_CONTEXT_API_URL = contextApiUrl;
+    }
+    if (pluginPath) {
+        env.OPENCODE_PLUGINS = pluginPath;
+    }
+    return env;
+}
+/**
+ * 设置进程事件处理器
+ * @param proc - 子进程实例
+ */
+function setupProcessHandlers(proc, port, hostname) {
+    proc.stdout?.on('data', () => {
+    });
+    proc.stderr?.on('data', () => {
+    });
+    proc.on('error', (err) => {
+        console.error(`\x1b[31m\x1b[1m${LOG_PREFIX}\x1b[0m ❌ Failed to start OpenCode server:`, err.message);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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