vite-plugin-opencode-assistant 1.0.15 → 1.0.17

package/lib/core/proxy-server.js

@@ -128,13 +128,268 @@ function generateBridgeScript(options) {
     if (event.data && event.data.type === "OPENCODE_SET_THEME") {
       setTheme(event.data.theme);
     }
+    
+    if (event.data && event.data.type === "OPENCODE_INSERT_FILE_PART") {
+      insertFilePart(event.data.element);
+    }
   });
 
+  // === \u4FDD\u5B58\u8F93\u5165\u6846\u5149\u6807\u4F4D\u7F6E ===
+  let savedRange = null;
+  
+  function setupPromptInputListener() {
+    const promptInput = document.querySelector('[data-component="prompt-input"]');
+    if (!promptInput) return;
+    
+    promptInput.addEventListener('blur', function() {
+      const selection = window.getSelection();
+      if (selection && selection.rangeCount > 0) {
+        const range = selection.getRangeAt(0);
+        if (promptInput.contains(range.commonAncestorContainer)) {
+          savedRange = range.cloneRange();
+        }
+      }
+    });
+    
+    promptInput.addEventListener('focus', function() {
+      savedRange = null;
+    });
+  }
+
+  // === \u63D2\u5165 File Part \u5230\u8F93\u5165\u6846 ===
+  function insertFilePart(element) {
+    const promptInput = document.querySelector('[data-component="prompt-input"]');
+    if (!promptInput) {
+      console.warn('[OpenCode Bridge] Prompt input not found');
+      return;
+    }
+
+    const { filePath, line, column, description, innerText, previewPageUrl, previewPageTitle } = element;
+
+    const selector = description || 'element';
+    let textPreview = '';
+    if (innerText && innerText.trim()) {
+      const trimmed = innerText.trim();
+      textPreview = trimmed.length > 5 ? trimmed.substring(0, 5) + '...' : trimmed;
+    }
+    const displayText = '@' + selector + (textPreview ? '(' + textPreview + ')' : '');
+
+    const jsonStr = JSON.stringify({
+      pageContext: {
+        url: previewPageUrl || '',
+        title: previewPageTitle || '',
+      },
+      nodeContext: {
+        filePath,
+        line,
+        column,
+        description,
+        innerText: innerText ? innerText.substring(0, 500) : ''
+      }
+    });
+
+    const span = document.createElement('span');
+    span.setAttribute('data-type', 'file');
+    span.setAttribute('data-path', jsonStr);
+    span.setAttribute('contenteditable', 'false');
+    
+    span.textContent = displayText;
+
+    if (savedRange) {
+      const range = savedRange;
+      range.collapse(false);
+      range.insertNode(span);
+      
+      const space = document.createTextNode('\\u00A0');
+      span.parentNode.insertBefore(space, span.nextSibling);
+      
+      const newRange = document.createRange();
+      newRange.setStartAfter(space);
+      newRange.collapse(true);
+      
+      promptInput.focus();
+      
+      const selection = window.getSelection();
+      if (selection) {
+        selection.removeAllRanges();
+        selection.addRange(newRange);
+      }
+      savedRange = null;
+      
+      promptInput.dispatchEvent(new Event('input', { bubbles: true }));
+      return;
+    }
+
+    const selection = window.getSelection();
+    if (selection && selection.rangeCount > 0) {
+      const range = selection.getRangeAt(0);
+      
+      if (promptInput.contains(range.commonAncestorContainer)) {
+        range.collapse(false);
+        range.insertNode(span);
+        
+        const space = document.createTextNode('\\u00A0');
+        span.parentNode.insertBefore(space, span.nextSibling);
+        
+        const newRange = document.createRange();
+        newRange.setStartAfter(space);
+        newRange.collapse(true);
+        selection.removeAllRanges();
+        selection.addRange(newRange);
+        
+        promptInput.dispatchEvent(new Event('input', { bubbles: true }));
+        return;
+      }
+    }
+
+    promptInput.appendChild(span);
+    const space = document.createTextNode('\\u00A0');
+    promptInput.appendChild(space);
+    
+    const newRange = document.createRange();
+    newRange.setStartAfter(space);
+    newRange.collapse(true);
+    const newSelection = window.getSelection();
+    if (newSelection) {
+      newSelection.removeAllRanges();
+      newSelection.addRange(newRange);
+    }
+    
+    promptInput.dispatchEvent(new Event('input', { bubbles: true }));
+    promptInput.focus();
+  }
+
+  // === \u601D\u8003\u72B6\u6001\u76D1\u542C (\u5B8C\u5168\u590D\u523B OpenCode Web \u5B9E\u73B0) ===
+  // OpenCode Web \u6838\u5FC3\u903B\u8F91:
+  // working = !!pending() || sessionStatus().type !== "idle"
+  // pending = \u6700\u540E\u4E00\u6761\u672A\u5B8C\u6210\u7684 assistant \u6D88\u606F (time.completed \u4E0D\u662F\u6570\u5B57)
+  // sessionStatus = sync.data.session_status[sessionID]
+  
+  let eventSource = null;
+  const sessionStatus = {};
+  const pendingMessages = {};
+
+  function getCurrentSessionID() {
+    const match = window.location.pathname.match(/\\/session\\/([^\\/]+)/);
+    return match ? match[1] : null;
+  }
+
+  function isPending(message) {
+    return message.role === 'assistant' && typeof message.time?.completed !== 'number';
+  }
+
+  function updateThinkingState(sessionID) {
+    const status = sessionStatus[sessionID];
+    const pending = pendingMessages[sessionID];
+    
+    const isThinking = !!pending || (status && status.type !== 'idle');
+    
+    if (window.parent !== window) {
+      window.parent.postMessage({
+        type: 'OPENCODE_THINKING_STATE',
+        thinking: isThinking,
+        sessionID: sessionID,
+        statusType: status?.type || 'idle',
+        hasPending: !!pending
+      }, '*');
+    }
+  }
+
+  function handleEvent(payload) {
+    const type = payload.type;
+    const props = payload.properties;
+
+    switch (type) {
+      case 'session.status': {
+        const sessionID = props.sessionID;
+        sessionStatus[sessionID] = props.status;
+        updateThinkingState(sessionID);
+        break;
+      }
+      
+      case 'message.updated': {
+        const info = props.info;
+        if (!info || !info.sessionID) break;
+        const sessionID = info.sessionID;
+        
+        if (info.role === 'assistant') {
+          if (isPending(info)) {
+            pendingMessages[sessionID] = info;
+          } else {
+            delete pendingMessages[sessionID];
+          }
+          updateThinkingState(sessionID);
+        }
+        break;
+      }
+      
+      case 'message.part.delta': {
+        const sessionID = props.sessionID;
+        if (sessionID && !pendingMessages[sessionID]) {
+          pendingMessages[sessionID] = { role: 'assistant', time: {} };
+          updateThinkingState(sessionID);
+        }
+        break;
+      }
+    }
+  }
+
+  function setupThinkingListener() {
+    if (eventSource) {
+      eventSource.close();
+    }
+
+    eventSource = new EventSource('/global/event');
+
+    eventSource.onmessage = function(event) {
+      try {
+        const data = JSON.parse(event.data);
+        const payload = data.payload;
+        if (!payload) return;
+        handleEvent(payload);
+      } catch (e) {
+        // ignore parse errors
+      }
+    };
+
+    eventSource.onerror = function(err) {
+      console.warn('[OpenCode Bridge] SSE connection error, retrying in 3s...');
+      eventSource.close();
+      setTimeout(setupThinkingListener, 3000);
+    };
+
+    console.log('[OpenCode Bridge] SSE listener setup complete');
+  }
+
   // === \u5C31\u7EEA\u901A\u77E5 ===
-  window.addEventListener("load", function() {
+  function init() {
     if (window.parent !== window) {
       window.parent.postMessage({ type: "OPENCODE_READY" }, "*");
     }
+    setupThinkingListener();
+    setupPromptInputListener();
+    
+    const observer = new MutationObserver(function(mutations) {
+      const promptInput = document.querySelector('[data-component="prompt-input"]');
+      if (promptInput && !promptInput._opencodeListenerAttached) {
+        setupPromptInputListener();
+        promptInput._opencodeListenerAttached = true;
+      }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init);
+  } else {
+    init();
+  }
+
+  window.addEventListener('beforeunload', function() {
+    if (eventSource) {
+      eventSource.close();
+      eventSource = null;
+    }
   });
 })();
 `;
@@ -162,7 +417,8 @@ function startProxyServer(targetUrl, port, options = {}) {
         headers: __spreadProps(__spreadValues({}, req.headers), {
           host: target.host,
           "accept-encoding": "identity"
-        })
+        }),
+        timeout: 0
       };
       const proxyReq = import_http.default.request(requestOptions, (proxyRes) => {
         var _a;
@@ -208,11 +464,19 @@ function startProxyServer(targetUrl, port, options = {}) {
         res.writeHead(502);
         res.end("Proxy error");
       });
+      proxyReq.on("socket", (socket) => {
+        socket.setTimeout(0);
+      });
+      req.on("socket", (socket) => {
+        socket.setTimeout(0);
+      });
       req.pipe(proxyReq);
     });
     server.on("error", (err) => {
       reject(err);
     });
+    server.timeout = 0;
+    server.keepAliveTimeout = 0;
     server.listen(port, () => {
       const address = server.address();
       const actualPort = typeof address === "object" && address ? address.port : port;

package/lib/core/service.d.ts

@@ -1,6 +1,7 @@
 import type { ResultPromise } from "execa";
 import type http from "http";
 import type { OpenCodeOptions, ServiceStartupTask } from "@vite-plugin-opencode-assistant/shared";
+import { ChromeMcpWarmupErrorType } from "@vite-plugin-opencode-assistant/shared";
 import type { OpenCodeAPI } from "./api.js";
 export declare class OpenCodeService {
     private config;
@@ -13,16 +14,22 @@ export declare class OpenCodeService {
     actualProxyPort: number;
     isStarted: boolean;
     private startPromise;
-    sessionUrl: string | null;
     private proxyServer;
     chromeMcpWarmupFailed: boolean;
+    chromeMcpWarmupErrorType: ChromeMcpWarmupErrorType | null;
+    chromeMcpWarmupErrorMessage: string | null;
     currentTask: {
         task: ServiceStartupTask;
         data?: Record<string, unknown>;
     } | null;
+    workspaceRoot: string | null;
     constructor(config: Required<OpenCodeOptions>, api: OpenCodeAPI, sseClients: Set<http.ServerResponse>, onPortAllocated: (port: number) => void, onProxyPortAllocated: (port: number) => void);
     private sendTaskUpdate;
     start(corsOrigins?: string[], contextApiUrl?: string, viteOrigin?: string): Promise<void>;
-    retryWarmupChromeMcp(viteOrigin?: string): Promise<boolean>;
+    retryWarmupChromeMcp(viteOrigin?: string): Promise<{
+        success: boolean;
+        errorType?: string;
+        errorMessage?: string;
+    }>;
     stop(): Promise<void>;
 }

package/lib/core/service.js

@@ -72,10 +72,12 @@ class OpenCodeService {
     __publicField(this, "actualProxyPort");
     __publicField(this, "isStarted", false);
     __publicField(this, "startPromise", null);
-    __publicField(this, "sessionUrl", null);
     __publicField(this, "proxyServer", null);
     __publicField(this, "chromeMcpWarmupFailed", false);
+    __publicField(this, "chromeMcpWarmupErrorType", null);
+    __publicField(this, "chromeMcpWarmupErrorMessage", null);
     __publicField(this, "currentTask", null);
+    __publicField(this, "workspaceRoot", null);
     var _a;
     this.actualWebPort = config.webPort;
     this.actualProxyPort = (_a = config.proxyPort) != null ? _a : import_shared.DEFAULT_PROXY_PORT;
@@ -149,8 +151,10 @@ Please install OpenCode first:
           log.debug(`Using port ${this.actualWebPort}`);
         }
         timer.checkpoint("Port allocated");
+        this.workspaceRoot = (0, import_system.findGitRoot)(process.cwd());
+        log.info(`Using workspace root: ${this.workspaceRoot}`);
         this.sendTaskUpdate("preparing_runtime");
-        const configDir = (0, import_opencode.prepareOpenCodeRuntime)(process.cwd());
+        const configDir = (0, import_opencode.prepareOpenCodeRuntime)(this.workspaceRoot);
         timer.checkpoint("Plugin setup complete");
         this.sendTaskUpdate("starting_web");
         log.debug("Starting OpenCode Web process...", {
@@ -162,7 +166,7 @@ Please install OpenCode first:
           port: this.actualWebPort,
           hostname: this.config.hostname,
           serverUrl: "",
-          cwd: process.cwd(),
+          cwd: this.workspaceRoot,
           configDir,
           corsOrigins,
           contextApiUrl
@@ -235,39 +239,30 @@ Please install OpenCode first:
         this.sendTaskUpdate("warming_up_chrome");
         let warmupFailed = false;
         try {
-          yield this.api.warmupChromeMcp(viteOrigin);
+          yield this.api.warmupChromeMcp(this.workspaceRoot, viteOrigin);
           timer.checkpoint("Chrome MCP warmup complete");
         } catch (e) {
           log.warn("Chrome MCP warmup failed", { error: e });
           this.chromeMcpWarmupFailed = true;
           warmupFailed = true;
+          if (e instanceof import_shared.ChromeMcpWarmupError) {
+            this.chromeMcpWarmupErrorType = e.type;
+            this.chromeMcpWarmupErrorMessage = e.message;
+          } else {
+            this.chromeMcpWarmupErrorType = import_shared.ChromeMcpWarmupErrorType.UNKNOWN;
+            this.chromeMcpWarmupErrorMessage = e instanceof Error ? e.message : String(e);
+          }
         }
         this.sendTaskUpdate("creating_session");
-        let sessionFailed = false;
-        try {
-          this.sessionUrl = yield this.api.getOrCreateSession();
-          timer.checkpoint("Session created");
-          log.debug(`Session URL: ${this.sessionUrl}`);
-        } catch (e) {
-          log.warn("Failed to get/create session", { error: e });
-          sessionFailed = true;
-        }
-        if (sessionFailed) {
-          this.sendTaskUpdate("session_creation_failed");
-          this.isStarted = false;
-          this.startPromise = null;
-        } else if (warmupFailed) {
-          this.sendTaskUpdate("chrome_mcp_failed", { sessionUrl: this.sessionUrl });
-          this.isStarted = true;
-        } else {
-          this.sendTaskUpdate("ready", { sessionUrl: this.sessionUrl });
-        }
-        if (!sessionFailed) {
+        if (warmupFailed) {
+          this.sendTaskUpdate("chrome_mcp_failed", {
+            errorType: this.chromeMcpWarmupErrorType,
+            errorMessage: this.chromeMcpWarmupErrorMessage
+          });
           this.isStarted = true;
         } else {
-          this.sessionUrl = null;
+          this.sendTaskUpdate("ready");
         }
-        log.debug(`OpenCode services started successfully: ${this.sessionUrl || webUrl}`);
         timer.end("\u2713 Services started successfully");
       }))();
       return this.startPromise;
@@ -275,12 +270,18 @@ Please install OpenCode first:
   }
   retryWarmupChromeMcp(viteOrigin) {
     return __async(this, null, function* () {
-      const success = yield this.api.retryWarmupChromeMcp(viteOrigin);
-      if (success) {
+      const result = yield this.api.retryWarmupChromeMcp(this.workspaceRoot, viteOrigin);
+      if (result.success) {
         this.chromeMcpWarmupFailed = false;
-        this.sendTaskUpdate("ready", { sessionUrl: this.sessionUrl });
+        this.sendTaskUpdate("ready");
+        return { success: true };
       }
-      return success;
+      const error = result.error;
+      return {
+        success: false,
+        errorType: error == null ? void 0 : error.type,
+        errorMessage: (error == null ? void 0 : error.message) || "Unknown error"
+      };
     });
   }
   stop() {

package/lib/endpoints/index.js

@@ -31,7 +31,7 @@ __reExport(endpoints_exports, require("./types.js"), module.exports);
 function setupMiddlewares(server, ctx) {
   (0, import_widget.setupWidgetEndpoints)(server, ctx);
   (0, import_context.setupContextEndpoint)(server, ctx);
-  (0, import_start.setupStartEndpoint)(server, ctx);
+  (0, import_start.setupStartEndpoint)(server);
   (0, import_sse.setupSseEndpoint)(server, ctx);
   (0, import_sessions.setupSessionsEndpoint)(server, ctx);
   (0, import_warmup.setupWarmupEndpoint)(server, ctx);

package/lib/endpoints/sse.js

@@ -67,9 +67,6 @@ function setupSseEndpoint(server, ctx) {
         Object.assign(statusPayload, ctx.currentTask.data);
       }
     }
-    if (ctx.sessionUrl) {
-      statusPayload.sessionUrl = ctx.sessionUrl;
-    }
     res.write(`data: ${JSON.stringify(statusPayload)}
 
 `);

package/lib/endpoints/start.d.ts

@@ -1,3 +1,2 @@
 import type { ViteDevServer } from "vite";
-import type { EndpointContext } from "./types.js";
-export declare function setupStartEndpoint(server: ViteDevServer, ctx: EndpointContext): void;
+export declare function setupStartEndpoint(server: ViteDevServer): void;

package/lib/endpoints/start.js

@@ -42,13 +42,13 @@ __export(start_exports, {
 module.exports = __toCommonJS(start_exports);
 var import_shared = require("@vite-plugin-opencode-assistant/shared");
 var import_shared2 = require("@vite-plugin-opencode-assistant/shared");
-function setupStartEndpoint(server, ctx) {
+function setupStartEndpoint(server) {
   server.middlewares.use(import_shared.START_API_PATH, (_req, res) => __async(null, null, function* () {
     const reqCtx = new import_shared2.RequestContext("GET", import_shared.START_API_PATH);
     res.setHeader("Content-Type", "application/json");
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.writeHead(200);
-    res.end(JSON.stringify({ success: true, sessionUrl: ctx.sessionUrl }));
+    res.end(JSON.stringify({ success: true }));
     reqCtx.end(200);
   }));
 }

package/lib/endpoints/types.d.ts

@@ -1,7 +1,6 @@
 import type { PageContext, SessionInfo, ServiceStartupTask } from "@vite-plugin-opencode-assistant/shared";
 import type http from "http";
 export interface EndpointContext {
-    get sessionUrl(): string | null;
     get webUrl(): string | null;
     get sseClients(): Set<http.ServerResponse>;
     get pageContext(): PageContext;
@@ -16,5 +15,9 @@ export interface EndpointContext {
     deleteSession: (id: string) => Promise<void>;
     resolveWidgetPath: () => string;
     resolveWidgetStylePath: () => string;
-    retryWarmupChromeMcp: () => Promise<boolean>;
+    retryWarmupChromeMcp: () => Promise<{
+        success: boolean;
+        errorType?: string;
+        errorMessage?: string;
+    }>;
 }

package/lib/endpoints/warmup.js

@@ -50,15 +50,27 @@ function setupWarmupEndpoint(server, ctx) {
       return;
     }
     try {
-      const success = yield ctx.retryWarmupChromeMcp();
+      const result = yield ctx.retryWarmupChromeMcp();
       res.setHeader("Content-Type", "application/json");
       res.writeHead(200);
-      res.end(JSON.stringify({ success }));
+      if (result.success) {
+        res.end(JSON.stringify({ success: true }));
+      } else {
+        res.end(JSON.stringify({
+          success: false,
+          errorType: result.errorType,
+          error: result.errorMessage
+        }));
+      }
     } catch (e) {
       log.error("Failed to retry warmup", { error: e });
       res.setHeader("Content-Type", "application/json");
       res.writeHead(500);
-      res.end(JSON.stringify({ success: false, error: String(e) }));
+      res.end(JSON.stringify({
+        success: false,
+        errorType: "UNKNOWN",
+        error: String(e)
+      }));
     }
   }));
 }

package/lib/index.js

@@ -92,7 +92,12 @@ function createOpenCodePlugin(options = {}) {
   let actualProxyPort = (_a = config.proxyPort) != null ? _a : import_shared.DEFAULT_PROXY_PORT;
   let pageContext = { url: "", title: "" };
   const sseClients = /* @__PURE__ */ new Set();
-  const api = new import_api.OpenCodeAPI(config.hostname, () => actualWebPort, config.warmupChromeMcp);
+  const api = new import_api.OpenCodeAPI(
+    config.hostname,
+    () => actualWebPort,
+    () => actualProxyPort,
+    config.warmupChromeMcp
+  );
   const service = new import_service.OpenCodeService(
     config,
     api,
@@ -117,9 +122,6 @@ function createOpenCodePlugin(options = {}) {
         let viteOrigin = "";
         const getViteOrigin = () => viteOrigin;
         (0, import_endpoints.setupMiddlewares)(server, {
-          get sessionUrl() {
-            return service.sessionUrl;
-          },
           get webUrl() {
             return actualWebPort ? `http://${config.hostname}:${actualWebPort}` : null;
           },
@@ -138,8 +140,8 @@ function createOpenCodePlugin(options = {}) {
           get currentTask() {
             return service.currentTask;
           },
-          getSessions: () => api.getSessions(),
-          createSession: () => api.createSession(),
+          getSessions: () => api.getSessions(service.workspaceRoot),
+          createSession: () => api.createSession(service.workspaceRoot),
           deleteSession: (id) => api.deleteSession(id),
           resolveWidgetPath: import_paths.resolveWidgetPath,
           resolveWidgetStylePath: import_paths.resolveWidgetStylePath,
@@ -195,15 +197,9 @@ function createOpenCodePlugin(options = {}) {
     transformIndexHtml(html) {
       const timer = log.timer("transformIndexHtml");
       const widget = (0, import_injector.injectWidget)({
-        webUrl: `http://${config.hostname}:${actualWebPort}`,
-        proxyUrl: `http://${config.hostname}:${actualProxyPort}`,
-        serverUrl: `http://${config.hostname}:${actualWebPort}`,
         position: config.position,
         theme: config.theme,
         open: config.open,
-        autoReload: config.autoReload,
-        cwd: process.cwd(),
-        // 不再注入 sessionUrl，客户端完全依赖 SSE 状态同步
         hotkey: config.hotkey
       });
       timer.end();