vite-plugin-opencode-assistant 1.0.15 → 1.0.16

package/es/core/proxy-server.js

@@ -104,11 +104,127 @@ function generateBridgeScript(options) {
     }
   });
 
+  // === \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();
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init);
+  } else {
+    init();
+  }
+
+  window.addEventListener('beforeunload', function() {
+    if (eventSource) {
+      eventSource.close();
+      eventSource = null;
+    }
   });
 })();
 `;
@@ -136,7 +252,8 @@ function startProxyServer(targetUrl, port, options = {}) {
         headers: __spreadProps(__spreadValues({}, req.headers), {
           host: target.host,
           "accept-encoding": "identity"
-        })
+        }),
+        timeout: 0
       };
       const proxyReq = http.request(requestOptions, (proxyRes) => {
         var _a;
@@ -182,11 +299,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/es/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/es/core/service.js

@@ -39,11 +39,14 @@ import { prepareOpenCodeRuntime, startOpenCodeWeb } from "@vite-plugin-opencode-
 import {
   DEFAULT_PROXY_PORT,
   SERVER_START_TIMEOUT,
-  createLogger
+  createLogger,
+  ChromeMcpWarmupError,
+  ChromeMcpWarmupErrorType
 } from "@vite-plugin-opencode-assistant/shared";
 import {
   checkOpenCodeInstalled,
   findAvailablePort,
+  findGitRoot,
   killOrphanOpenCodeProcesses,
   waitForServer
 } from "../utils/system.js";
@@ -61,10 +64,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 : DEFAULT_PROXY_PORT;
@@ -138,8 +143,10 @@ Please install OpenCode first:
           log.debug(`Using port ${this.actualWebPort}`);
         }
         timer.checkpoint("Port allocated");
+        this.workspaceRoot = findGitRoot(process.cwd());
+        log.info(`Using workspace root: ${this.workspaceRoot}`);
         this.sendTaskUpdate("preparing_runtime");
-        const configDir = prepareOpenCodeRuntime(process.cwd());
+        const configDir = prepareOpenCodeRuntime(this.workspaceRoot);
         timer.checkpoint("Plugin setup complete");
         this.sendTaskUpdate("starting_web");
         log.debug("Starting OpenCode Web process...", {
@@ -151,7 +158,7 @@ Please install OpenCode first:
           port: this.actualWebPort,
           hostname: this.config.hostname,
           serverUrl: "",
-          cwd: process.cwd(),
+          cwd: this.workspaceRoot,
           configDir,
           corsOrigins,
           contextApiUrl
@@ -224,39 +231,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 ChromeMcpWarmupError) {
+            this.chromeMcpWarmupErrorType = e.type;
+            this.chromeMcpWarmupErrorMessage = e.message;
+          } else {
+            this.chromeMcpWarmupErrorType = 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;
@@ -264,12 +262,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/es/endpoints/index.js

@@ -8,7 +8,7 @@ export * from "./types.js";
 function setupMiddlewares(server, ctx) {
   setupWidgetEndpoints(server, ctx);
   setupContextEndpoint(server, ctx);
-  setupStartEndpoint(server, ctx);
+  setupStartEndpoint(server);
   setupSseEndpoint(server, ctx);
   setupSessionsEndpoint(server, ctx);
   setupWarmupEndpoint(server, ctx);

package/es/endpoints/sse.js

@@ -45,9 +45,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/es/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/es/endpoints/start.js

@@ -20,13 +20,13 @@ var __async = (__this, __arguments, generator) => {
 };
 import { START_API_PATH } from "@vite-plugin-opencode-assistant/shared";
 import { RequestContext } from "@vite-plugin-opencode-assistant/shared";
-function setupStartEndpoint(server, ctx) {
+function setupStartEndpoint(server) {
   server.middlewares.use(START_API_PATH, (_req, res) => __async(null, null, function* () {
     const reqCtx = new RequestContext("GET", 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/es/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/es/endpoints/warmup.js

@@ -28,15 +28,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/es/index.js

@@ -68,7 +68,12 @@ function createOpenCodePlugin(options = {}) {
   let actualProxyPort = (_a = config.proxyPort) != null ? _a : DEFAULT_PROXY_PORT;
   let pageContext = { url: "", title: "" };
   const sseClients = /* @__PURE__ */ new Set();
-  const api = new OpenCodeAPI(config.hostname, () => actualWebPort, config.warmupChromeMcp);
+  const api = new OpenCodeAPI(
+    config.hostname,
+    () => actualWebPort,
+    () => actualProxyPort,
+    config.warmupChromeMcp
+  );
   const service = new OpenCodeService(
     config,
     api,
@@ -93,9 +98,6 @@ function createOpenCodePlugin(options = {}) {
         let viteOrigin = "";
         const getViteOrigin = () => viteOrigin;
         setupMiddlewares(server, {
-          get sessionUrl() {
-            return service.sessionUrl;
-          },
           get webUrl() {
             return actualWebPort ? `http://${config.hostname}:${actualWebPort}` : null;
           },
@@ -114,8 +116,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,
           resolveWidgetStylePath,
@@ -171,15 +173,9 @@ function createOpenCodePlugin(options = {}) {
     transformIndexHtml(html) {
       const timer = log.timer("transformIndexHtml");
       const widget = 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();

package/es/utils/system.d.ts

@@ -4,3 +4,4 @@ export declare function checkOpenCodeInstalled(): Promise<boolean>;
 export declare function isPortAvailable(port: number, hostname?: string): Promise<boolean>;
 export declare function findAvailablePort(startPort: number, hostname?: string, maxTries?: number): Promise<number>;
 export declare function killOrphanOpenCodeProcesses(): Promise<number>;
+export declare function findGitRoot(startDir: string, maxDepth?: number): string;

package/es/utils/system.js

@@ -19,8 +19,10 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 import { spawn } from "child_process";
+import fs from "fs";
 import http from "http";
 import net from "net";
+import path from "path";
 import { MAX_PORT_TRIES, SERVER_CHECK_INTERVAL } from "@vite-plugin-opencode-assistant/shared";
 import { PerformanceTimer, createLogger } from "@vite-plugin-opencode-assistant/shared";
 const log = createLogger("Utils");
@@ -182,6 +184,31 @@ function killOrphanProcessesOnWindows(resolve, timer) {
     resolve(0);
   });
 }
+function findGitRoot(startDir, maxDepth = 10) {
+  const timer = log.timer("findGitRoot", { startDir, maxDepth });
+  let currentDir = startDir;
+  let depth = 0;
+  while (depth < maxDepth) {
+    const gitDir = path.join(currentDir, ".git");
+    try {
+      if (fs.existsSync(gitDir)) {
+        timer.end(`\u2713 Found git root at depth ${depth}: ${currentDir}`);
+        return currentDir;
+      }
+    } catch (err) {
+      log.debug(`Error checking .git directory at ${currentDir}`, { error: err.message });
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      log.debug("Reached filesystem root");
+      break;
+    }
+    currentDir = parentDir;
+    depth++;
+  }
+  timer.end(`\u274C No git root found after ${depth} levels, using start directory`);
+  return startDir;
+}
 function killOrphanProcessesOnUnix(resolve, timer) {
   var _a;
   log.debug("Using Unix method to find orphan processes");
@@ -236,6 +263,7 @@ function killOrphanProcessesOnUnix(resolve, timer) {
 export {
   checkOpenCodeInstalled,
   findAvailablePort,
+  findGitRoot,
   isPortAvailable,
   killOrphanOpenCodeProcesses,
   waitForServer

package/lib/client/App.vue.d.ts

@@ -0,0 +1,6 @@
+import type { WidgetOptions } from "@vite-plugin-opencode-assistant/shared";
+type __VLS_Props = {
+    config: Partial<WidgetOptions>;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;