vite-plugin-opencode-assistant 1.0.14 → 1.0.16

package/es/core/proxy-server.js

@@ -104,90 +104,221 @@ 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;
+    }
   });
 })();
 `;
 }
 function startProxyServer(targetUrl, port, options = {}) {
-  const target = new URL(targetUrl);
-  const bridgeScript = generateBridgeScript(options);
-  const server = http.createServer((req, res) => {
-    if (req.url === "/__opencode_bridge__.js") {
-      const body = bridgeScript;
-      res.writeHead(200, {
-        "content-type": "application/javascript; charset=utf-8",
-        "cache-control": "no-store",
-        "content-length": Buffer.byteLength(body)
-      });
-      res.end(body);
-      return;
-    }
-    const options2 = {
-      hostname: target.hostname,
-      port: target.port,
-      path: req.url,
-      method: req.method,
-      headers: __spreadProps(__spreadValues({}, req.headers), {
-        host: target.host,
-        // Don't accept compressed responses so we can modify HTML
-        "accept-encoding": "identity"
-      })
-    };
-    const proxyReq = http.request(options2, (proxyRes) => {
-      var _a;
-      const rawContentType = proxyRes.headers["content-type"];
-      const contentType = Array.isArray(rawContentType) ? (_a = rawContentType[0]) != null ? _a : "" : rawContentType != null ? rawContentType : "";
-      if (contentType.includes("text/html")) {
-        const chunks = [];
-        proxyRes.on("data", (chunk) => {
-          chunks.push(chunk);
-        });
-        proxyRes.on("end", () => {
-          let body = Buffer.concat(chunks).toString("utf-8");
-          if (body.match(/<\/head>/i)) {
-            body = body.replace(
-              /<\/head>/i,
-              '<script src="/__opencode_bridge__.js"></script></head>'
-            );
-          } else if (body.match(/<\/body>/i)) {
-            body = body.replace(
-              /<\/body>/i,
-              '<script src="/__opencode_bridge__.js"></script></body>'
-            );
-          } else {
-            body += '<script src="/__opencode_bridge__.js"></script>';
-          }
-          const headers = {};
-          for (const [key, value] of Object.entries(proxyRes.headers)) {
-            if (value !== void 0 && key !== "content-encoding" && key !== "transfer-encoding" && key !== "content-length") {
-              headers[key] = value;
-            }
-          }
-          headers["content-length"] = Buffer.byteLength(body);
-          res.writeHead(proxyRes.statusCode || 200, headers);
-          res.end(body);
+  return new Promise((resolve, reject) => {
+    const target = new URL(targetUrl);
+    const bridgeScript = generateBridgeScript(options);
+    const server = http.createServer((req, res) => {
+      if (req.url === "/__opencode_bridge__.js") {
+        const body = bridgeScript;
+        res.writeHead(200, {
+          "content-type": "application/javascript; charset=utf-8",
+          "cache-control": "no-store",
+          "content-length": Buffer.byteLength(body)
         });
-      } else {
-        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
-        proxyRes.pipe(res);
+        res.end(body);
+        return;
       }
+      const requestOptions = {
+        hostname: target.hostname,
+        port: target.port,
+        path: req.url,
+        method: req.method,
+        headers: __spreadProps(__spreadValues({}, req.headers), {
+          host: target.host,
+          "accept-encoding": "identity"
+        }),
+        timeout: 0
+      };
+      const proxyReq = http.request(requestOptions, (proxyRes) => {
+        var _a;
+        const rawContentType = proxyRes.headers["content-type"];
+        const contentType = Array.isArray(rawContentType) ? (_a = rawContentType[0]) != null ? _a : "" : rawContentType != null ? rawContentType : "";
+        if (contentType.includes("text/html")) {
+          const chunks = [];
+          proxyRes.on("data", (chunk) => {
+            chunks.push(chunk);
+          });
+          proxyRes.on("end", () => {
+            let body = Buffer.concat(chunks).toString("utf-8");
+            if (body.match(/<\/head>/i)) {
+              body = body.replace(
+                /<\/head>/i,
+                '<script src="/__opencode_bridge__.js"></script></head>'
+              );
+            } else if (body.match(/<\/body>/i)) {
+              body = body.replace(
+                /<\/body>/i,
+                '<script src="/__opencode_bridge__.js"></script></body>'
+              );
+            } else {
+              body += '<script src="/__opencode_bridge__.js"></script>';
+            }
+            const headers = {};
+            for (const [key, value] of Object.entries(proxyRes.headers)) {
+              if (value !== void 0 && key !== "content-encoding" && key !== "transfer-encoding" && key !== "content-length") {
+                headers[key] = value;
+              }
+            }
+            headers["content-length"] = Buffer.byteLength(body);
+            res.writeHead(proxyRes.statusCode || 200, headers);
+            res.end(body);
+          });
+        } else {
+          res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+          proxyRes.pipe(res);
+        }
+      });
+      proxyReq.on("error", (err) => {
+        log.error("Proxy error", { error: err.message, url: req.url });
+        res.writeHead(502);
+        res.end("Proxy error");
+      });
+      proxyReq.on("socket", (socket) => {
+        socket.setTimeout(0);
+      });
+      req.on("socket", (socket) => {
+        socket.setTimeout(0);
+      });
+      req.pipe(proxyReq);
     });
-    proxyReq.on("error", (err) => {
-      log.error("Proxy error", { error: err.message, url: req.url });
-      res.writeHead(502);
-      res.end("Proxy error");
+    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;
+      log.info(`Proxy server started on port ${actualPort} -> ${targetUrl}`);
+      resolve({ server, actualPort });
     });
-    req.pipe(proxyReq);
-  });
-  server.listen(port, () => {
-    log.info(`Proxy server started on port ${port} -> ${targetUrl}`);
   });
-  return server;
 }
 export {
   startProxyServer

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;
@@ -92,7 +97,7 @@ class OpenCodeService {
         return this.startPromise;
       }
       this.startPromise = (() => __async(this, null, function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const timer = log.timer("startServices", {
           corsOrigins,
           contextApiUrl,
@@ -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
@@ -161,7 +168,10 @@ Please install OpenCode first:
         log.info(`Waiting for OpenCode Web to become ready at ${webUrl}...`);
         this.sendTaskUpdate("waiting_web_ready");
         try {
-          yield waitForServer(webUrl, SERVER_START_TIMEOUT);
+          yield waitForServer(webUrl, SERVER_START_TIMEOUT, this.webProcess);
+          if (((_a = this.webProcess) == null ? void 0 : _a.exitCode) !== null && ((_b = this.webProcess) == null ? void 0 : _b.exitCode) !== void 0) {
+            throw new Error(`OpenCode process exited with code ${this.webProcess.exitCode}`);
+          }
           log.info(`OpenCode Web started at ${webUrl}`);
         } catch (e) {
           log.error("OpenCode Web failed to start", { error: e });
@@ -171,60 +181,80 @@ Please install OpenCode first:
           return;
         }
         this.sendTaskUpdate("starting_proxy");
-        this.actualProxyPort = yield findAvailablePort(
-          (_a = this.config.proxyPort) != null ? _a : DEFAULT_PROXY_PORT,
-          this.config.hostname
-        );
+        let proxyStartPort = (_c = this.config.proxyPort) != null ? _c : DEFAULT_PROXY_PORT;
+        if (proxyStartPort === this.actualWebPort) {
+          proxyStartPort = this.actualWebPort + 1;
+          log.debug(`Proxy start port conflicts with web port, using ${proxyStartPort} instead`);
+        }
+        this.actualProxyPort = yield findAvailablePort(proxyStartPort, this.config.hostname);
         this.onProxyPortAllocated(this.actualProxyPort);
-        if (this.actualProxyPort !== ((_b = this.config.proxyPort) != null ? _b : DEFAULT_PROXY_PORT)) {
+        if (this.actualProxyPort !== ((_d = this.config.proxyPort) != null ? _d : DEFAULT_PROXY_PORT)) {
           log.info(
-            `Proxy port ${(_c = this.config.proxyPort) != null ? _c : DEFAULT_PROXY_PORT} is in use, using ${this.actualProxyPort} instead`
+            `Proxy port ${(_e = this.config.proxyPort) != null ? _e : DEFAULT_PROXY_PORT} is in use, using ${this.actualProxyPort} instead`
           );
         } else {
           log.debug(`Using proxy port ${this.actualProxyPort}`);
         }
-        this.proxyServer = startProxyServer(webUrl, this.actualProxyPort, {
-          theme: this.config.theme,
-          language: this.config.language,
-          settings: this.config.settings
-        });
+        try {
+          const result = yield startProxyServer(webUrl, this.actualProxyPort, {
+            theme: this.config.theme,
+            language: this.config.language,
+            settings: this.config.settings
+          });
+          this.proxyServer = result.server;
+          if (result.actualPort !== this.actualProxyPort) {
+            log.info(
+              `Proxy port ${this.actualProxyPort} was taken, using ${result.actualPort} instead`
+            );
+            this.actualProxyPort = result.actualPort;
+            this.onProxyPortAllocated(this.actualProxyPort);
+          }
+        } catch (err) {
+          const nodeErr = err;
+          if (nodeErr.code === "EADDRINUSE") {
+            log.warn(`Proxy port ${this.actualProxyPort} became unavailable, trying next port...`);
+            const nextPort = yield findAvailablePort(this.actualProxyPort + 1, this.config.hostname);
+            const result = yield startProxyServer(webUrl, nextPort, {
+              theme: this.config.theme,
+              language: this.config.language,
+              settings: this.config.settings
+            });
+            this.proxyServer = result.server;
+            this.actualProxyPort = result.actualPort;
+            this.onProxyPortAllocated(this.actualProxyPort);
+            log.info(`Proxy server started on fallback port ${this.actualProxyPort}`);
+          } else {
+            throw err;
+          }
+        }
         timer.checkpoint("Proxy server started");
         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;
@@ -232,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();