vite-plugin-opencode-assistant 1.0.13 → 1.0.14

package/es/core/api.js

@@ -35,13 +35,36 @@ function sleep(ms) {
 function base64Encode(str) {
   return Buffer.from(str).toString("base64");
 }
+function extractTextFromResponse(data) {
+  if (!data || typeof data !== "object") return null;
+  const obj = data;
+  if (obj.parts && Array.isArray(obj.parts)) {
+    const textParts = obj.parts.filter(
+      (p) => p && typeof p === "object" && p.type === "text"
+    ).map((p) => p.text).filter(Boolean);
+    if (textParts.length > 0) return textParts.join("");
+  }
+  if (obj.text && typeof obj.text === "string") {
+    return obj.text;
+  }
+  if (obj.content && typeof obj.content === "string") {
+    return obj.content;
+  }
+  if (obj.message && typeof obj.message === "string") {
+    return obj.message;
+  }
+  if (typeof data === "string") {
+    return data;
+  }
+  return null;
+}
 class OpenCodeAPI {
   constructor(hostname, getPort, warmupChromeMcpConfig = false) {
     __publicField(this, "hostname", hostname);
     __publicField(this, "getPort", getPort);
     __publicField(this, "warmupChromeMcpConfig", warmupChromeMcpConfig);
   }
-  createHttpRequest(options, body) {
+  createHttpRequest(options, body, timeout) {
     const timer = new PerformanceTimer("HTTP Request", {
       operation: `${options.method || "GET"} ${options.path}`
     });
@@ -64,6 +87,13 @@ class OpenCodeAPI {
         timer.end("\u274C Request failed");
         reject(e);
       });
+      if (timeout) {
+        req.setTimeout(timeout, () => {
+          timer.end("\u274C Request timeout");
+          req.destroy();
+          reject(new Error(`Request timeout after ${timeout}ms`));
+        });
+      }
       if (body) req.write(body);
       req.end();
     });
@@ -217,24 +247,16 @@ class OpenCodeAPI {
       try {
         const warmupSession = yield this.createSession(DEFAULT_RETRIES, "__chrome_mcp_warmup__");
         warmupSessionId = warmupSession.id;
-        let chromeToolIds;
-        try {
-          const toolIds = yield this.getToolIds();
-          chromeToolIds = toolIds.filter((toolId) => /chrome[-_]?devtools/i.test(toolId));
-          log.debug("Resolved Chrome MCP tool ids", {
-            chromeToolIds
-          });
-        } catch (e) {
-          log.debug("Failed to resolve Chrome MCP tool ids", { error: e });
-        }
         const prompt = [
           "Call the browser tool list_pages immediately to establish the Chrome DevTools MCP connection.",
           viteOrigin ? `If there are no pages, call new_page with ${viteOrigin}.` : "If there are no pages, call new_page with about:blank.",
           "Do not read or modify project files.",
           "Do not use any non-browser tools.",
-          "After the tool call is complete, reply with exactly: ready"
+          "After the tool call is complete, reply with exactly: ready",
+          "If the tool call fails, reply with exactly: fail"
         ].join(" ");
-        yield this.createHttpRequest(
+        const WARMUP_TIMEOUT = 3e4;
+        const data = yield this.createHttpRequest(
           {
             hostname: this.hostname,
             port: this.getPort(),
@@ -244,14 +266,19 @@ class OpenCodeAPI {
           },
           JSON.stringify({
             system: "You are warming up Chrome DevTools MCP during startup. You must use the available browser tools immediately before replying.",
-            tools: (chromeToolIds == null ? void 0 : chromeToolIds.length) ? chromeToolIds : void 0,
             parts: [{ type: "text", text: prompt }]
-          })
+          }),
+          WARMUP_TIMEOUT
         );
+        const responseText = extractTextFromResponse(data);
+        if (!(responseText == null ? void 0 : responseText.toLowerCase().includes("ready"))) {
+          throw new Error(`Chrome MCP warmup failed: ${responseText || "No response"}`);
+        }
         timer.end("Chrome MCP warmed up");
       } catch (e) {
         log.warn("Failed to warm up Chrome MCP", { error: e });
         timer.end("Chrome MCP warmup skipped");
+        throw e;
       } finally {
         if (warmupSessionId) {
           try {
@@ -288,6 +315,61 @@ class OpenCodeAPI {
       return url;
     });
   }
+  retryWarmupChromeMcp(viteOrigin) {
+    return __async(this, null, function* () {
+      const timer = log.timer("retryWarmupChromeMcp", { viteOrigin });
+      let warmupSessionId = null;
+      try {
+        const warmupSession = yield this.createSession(DEFAULT_RETRIES, "__chrome_mcp_warmup__");
+        warmupSessionId = warmupSession.id;
+        const prompt = [
+          "Call the browser tool list_pages immediately to establish the Chrome DevTools MCP connection.",
+          viteOrigin ? `If there are no pages, call new_page with ${viteOrigin}.` : "If there are no pages, call new_page with about:blank.",
+          "Do not read or modify project files.",
+          "Do not use any non-browser tools.",
+          "After the tool call is complete, reply with exactly: ready",
+          "If the tool call fails, reply with exactly: fail"
+        ].join(" ");
+        const WARMUP_TIMEOUT = 6e4;
+        const data = yield this.createHttpRequest(
+          {
+            hostname: this.hostname,
+            port: this.getPort(),
+            path: `/session/${warmupSessionId}/message`,
+            method: "POST",
+            headers: { "Content-Type": "application/json" }
+          },
+          JSON.stringify({
+            system: "You are warming up Chrome DevTools MCP during startup. You must use the available browser tools immediately before replying.",
+            parts: [{ type: "text", text: prompt }]
+          }),
+          WARMUP_TIMEOUT
+        );
+        log.debug("Chrome MCP warmup response:", { data });
+        const responseText = extractTextFromResponse(data);
+        if (!(responseText == null ? void 0 : responseText.toLowerCase().includes("ready"))) {
+          throw new Error(`Chrome MCP warmup failed: ${responseText || "No response"}`);
+        }
+        timer.end("Chrome MCP warmed up successfully");
+        return true;
+      } catch (e) {
+        log.warn("Failed to retry warm up Chrome MCP", { error: e });
+        timer.end("Chrome MCP warmup retry failed");
+        return false;
+      } finally {
+        if (warmupSessionId) {
+          try {
+            yield this.deleteSession(warmupSessionId, 5);
+          } catch (e) {
+            log.warn("Failed to delete warmup session after retries", {
+              error: e,
+              warmupSessionId
+            });
+          }
+        }
+      }
+    });
+  }
 }
 export {
   OpenCodeAPI

package/es/core/service.d.ts

@@ -1,6 +1,6 @@
 import type { ResultPromise } from "execa";
 import type http from "http";
-import type { OpenCodeOptions } from "@vite-plugin-opencode-assistant/shared";
+import type { OpenCodeOptions, ServiceStartupTask } from "@vite-plugin-opencode-assistant/shared";
 import type { OpenCodeAPI } from "./api.js";
 export declare class OpenCodeService {
     private config;
@@ -15,7 +15,14 @@ export declare class OpenCodeService {
     private startPromise;
     sessionUrl: string | null;
     private proxyServer;
+    chromeMcpWarmupFailed: boolean;
+    currentTask: {
+        task: ServiceStartupTask;
+        data?: Record<string, unknown>;
+    } | 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>;
     stop(): Promise<void>;
 }

package/es/core/service.js

@@ -1,5 +1,19 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -49,10 +63,24 @@ class OpenCodeService {
     __publicField(this, "startPromise", null);
     __publicField(this, "sessionUrl", null);
     __publicField(this, "proxyServer", null);
+    __publicField(this, "chromeMcpWarmupFailed", false);
+    __publicField(this, "currentTask", null);
     var _a;
     this.actualWebPort = config.webPort;
     this.actualProxyPort = (_a = config.proxyPort) != null ? _a : DEFAULT_PROXY_PORT;
   }
+  sendTaskUpdate(task, data) {
+    this.currentTask = __spreadValues({ task }, data);
+    this.sseClients.forEach((client) => {
+      try {
+        client.write(`data: ${JSON.stringify(__spreadValues({ type: "TASK_UPDATE", task }, data))}
+
+`);
+      } catch (e) {
+        log.debug("Failed to send TASK_UPDATE event", { error: e });
+      }
+    });
+  }
   start(corsOrigins, contextApiUrl, viteOrigin) {
     return __async(this, null, function* () {
       if (this.isStarted && this.webProcess) {
@@ -75,6 +103,7 @@ class OpenCodeService {
         if (orphanCount > 0) {
           log.debug(`Killed ${orphanCount} orphan OpenCode process(es)`);
         }
+        this.sendTaskUpdate("checking_opencode");
         if (!(yield checkOpenCodeInstalled())) {
           log.error(`OpenCode is not installed!
 
@@ -94,10 +123,13 @@ Please install OpenCode first:
   mise use -g opencode               # Any OS
   nix run nixpkgs#opencode           # or github:anomalyco/opencode for latest dev branch
         `);
+          this.sendTaskUpdate("opencode_not_installed");
+          this.startPromise = null;
           timer.end("\u274C OpenCode not installed");
           return;
         }
         timer.checkpoint("OpenCode installation verified");
+        this.sendTaskUpdate("allocating_port");
         this.actualWebPort = yield findAvailablePort(this.config.webPort, this.config.hostname);
         this.onPortAllocated(this.actualWebPort);
         if (this.actualWebPort !== this.config.webPort) {
@@ -106,8 +138,10 @@ Please install OpenCode first:
           log.debug(`Using port ${this.actualWebPort}`);
         }
         timer.checkpoint("Port allocated");
+        this.sendTaskUpdate("preparing_runtime");
         const configDir = prepareOpenCodeRuntime(process.cwd());
         timer.checkpoint("Plugin setup complete");
+        this.sendTaskUpdate("starting_web");
         log.debug("Starting OpenCode Web process...", {
           port: this.actualWebPort,
           hostname: this.config.hostname,
@@ -125,8 +159,18 @@ Please install OpenCode first:
         timer.checkpoint("Web process started");
         const webUrl = `http://${this.config.hostname}:${this.actualWebPort}`;
         log.info(`Waiting for OpenCode Web to become ready at ${webUrl}...`);
-        yield waitForServer(webUrl, SERVER_START_TIMEOUT);
-        log.info(`OpenCode Web started at ${webUrl}`);
+        this.sendTaskUpdate("waiting_web_ready");
+        try {
+          yield waitForServer(webUrl, SERVER_START_TIMEOUT);
+          log.info(`OpenCode Web started at ${webUrl}`);
+        } catch (e) {
+          log.error("OpenCode Web failed to start", { error: e });
+          this.sendTaskUpdate("web_start_timeout");
+          this.startPromise = null;
+          timer.end("\u274C Web start timeout");
+          return;
+        }
+        this.sendTaskUpdate("starting_proxy");
         this.actualProxyPort = yield findAvailablePort(
           (_a = this.config.proxyPort) != null ? _a : DEFAULT_PROXY_PORT,
           this.config.hostname
@@ -145,33 +189,57 @@ Please install OpenCode first:
           settings: this.config.settings
         });
         timer.checkpoint("Proxy server started");
-        yield this.api.warmupChromeMcp(viteOrigin);
-        timer.checkpoint("Chrome MCP warmup complete");
+        this.sendTaskUpdate("warming_up_chrome");
+        let warmupFailed = false;
+        try {
+          yield this.api.warmupChromeMcp(viteOrigin);
+          timer.checkpoint("Chrome MCP warmup complete");
+        } catch (e) {
+          log.warn("Chrome MCP warmup failed", { error: e });
+          this.chromeMcpWarmupFailed = true;
+          warmupFailed = true;
+        }
+        this.sendTaskUpdate("creating_session");
+        let sessionFailed = false;
         try {
           this.sessionUrl = yield this.api.getOrCreateSession();
           timer.checkpoint("Session created");
           log.debug(`Session URL: ${this.sessionUrl}`);
-          this.sseClients.forEach((client) => {
-            try {
-              client.write(
-                `data: ${JSON.stringify({ type: "SESSION_READY", sessionUrl: this.sessionUrl })}
-
-`
-              );
-            } catch (e) {
-              log.debug("Failed to send SESSION_READY event", { error: e });
-            }
-          });
         } 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) {
+          this.isStarted = true;
+        } else {
+          this.sessionUrl = null;
         }
-        this.isStarted = true;
         log.debug(`OpenCode services started successfully: ${this.sessionUrl || webUrl}`);
         timer.end("\u2713 Services started successfully");
       }))();
       return this.startPromise;
     });
   }
+  retryWarmupChromeMcp(viteOrigin) {
+    return __async(this, null, function* () {
+      const success = yield this.api.retryWarmupChromeMcp(viteOrigin);
+      if (success) {
+        this.chromeMcpWarmupFailed = false;
+        this.sendTaskUpdate("ready", { sessionUrl: this.sessionUrl });
+      }
+      return success;
+    });
+  }
   stop() {
     return __async(this, null, function* () {
       const timer = log.timer("stopServices");

package/es/endpoints/index.js

@@ -3,6 +3,7 @@ import { setupContextEndpoint } from "./context.js";
 import { setupStartEndpoint } from "./start.js";
 import { setupSseEndpoint } from "./sse.js";
 import { setupSessionsEndpoint } from "./sessions.js";
+import { setupWarmupEndpoint } from "./warmup.js";
 export * from "./types.js";
 function setupMiddlewares(server, ctx) {
   setupWidgetEndpoints(server, ctx);
@@ -10,6 +11,7 @@ function setupMiddlewares(server, ctx) {
   setupStartEndpoint(server, ctx);
   setupSseEndpoint(server, ctx);
   setupSessionsEndpoint(server, ctx);
+  setupWarmupEndpoint(server, ctx);
 }
 export {
   setupMiddlewares

package/es/endpoints/sse.js

@@ -35,13 +35,22 @@ function setupSseEndpoint(server, ctx) {
     res.write(`data: ${JSON.stringify({ type: "CONNECTED" })}
 
 `);
+    const statusPayload = { type: "STATUS_SYNC" };
+    if (ctx.isServiceStarted !== void 0) {
+      statusPayload.isStarted = ctx.isServiceStarted;
+    }
+    if (ctx.currentTask) {
+      statusPayload.task = ctx.currentTask.task;
+      if (ctx.currentTask.data) {
+        Object.assign(statusPayload, ctx.currentTask.data);
+      }
+    }
     if (ctx.sessionUrl) {
-      res.write(
-        `data: ${JSON.stringify({ type: "SESSION_READY", sessionUrl: ctx.sessionUrl })}
-
-`
-      );
+      statusPayload.sessionUrl = ctx.sessionUrl;
     }
+    res.write(`data: ${JSON.stringify(statusPayload)}
+
+`);
     req.on("close", () => {
       ctx.sseClients.delete(res);
       log.debug("SSE client disconnected", {

package/es/endpoints/types.d.ts

@@ -1,4 +1,4 @@
-import type { PageContext, SessionInfo } from "@vite-plugin-opencode-assistant/shared";
+import type { PageContext, SessionInfo, ServiceStartupTask } from "@vite-plugin-opencode-assistant/shared";
 import type http from "http";
 export interface EndpointContext {
     get sessionUrl(): string | null;
@@ -6,9 +6,15 @@ export interface EndpointContext {
     get sseClients(): Set<http.ServerResponse>;
     get pageContext(): PageContext;
     set pageContext(ctx: PageContext);
+    get isServiceStarted(): boolean;
+    get currentTask(): {
+        task: ServiceStartupTask;
+        data?: Record<string, unknown>;
+    } | null;
     getSessions: () => Promise<SessionInfo[]>;
     createSession: () => Promise<SessionInfo>;
     deleteSession: (id: string) => Promise<void>;
     resolveWidgetPath: () => string;
     resolveWidgetStylePath: () => string;
+    retryWarmupChromeMcp: () => Promise<boolean>;
 }

package/es/endpoints/warmup.d.ts

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

package/es/endpoints/warmup.js

@@ -0,0 +1,45 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { createLogger } from "@vite-plugin-opencode-assistant/shared";
+const log = createLogger("Endpoints:Warmup");
+function setupWarmupEndpoint(server, ctx) {
+  server.middlewares.use("/__opencode_warmup__", (req, res) => __async(null, null, function* () {
+    if (req.method !== "POST") {
+      res.writeHead(405);
+      res.end("Method not allowed");
+      return;
+    }
+    try {
+      const success = yield ctx.retryWarmupChromeMcp();
+      res.setHeader("Content-Type", "application/json");
+      res.writeHead(200);
+      res.end(JSON.stringify({ success }));
+    } 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) }));
+    }
+  }));
+}
+export {
+  setupWarmupEndpoint
+};

package/es/index.js

@@ -90,6 +90,8 @@ function createOpenCodePlugin(options = {}) {
       return __async(this, null, function* () {
         var _a2, _b2;
         const timer = log.timer("configureServer");
+        let viteOrigin = "";
+        const getViteOrigin = () => viteOrigin;
         setupMiddlewares(server, {
           get sessionUrl() {
             return service.sessionUrl;
@@ -106,11 +108,18 @@ function createOpenCodePlugin(options = {}) {
           set pageContext(ctx) {
             pageContext = ctx;
           },
+          get isServiceStarted() {
+            return service.isStarted;
+          },
+          get currentTask() {
+            return service.currentTask;
+          },
           getSessions: () => api.getSessions(),
           createSession: () => api.createSession(),
           deleteSession: (id) => api.deleteSession(id),
           resolveWidgetPath,
-          resolveWidgetStylePath
+          resolveWidgetStylePath,
+          retryWarmupChromeMcp: () => service.retryWarmupChromeMcp(getViteOrigin())
         });
         (_a2 = server.httpServer) == null ? void 0 : _a2.on("listening", () => __async(null, null, function* () {
           var _a3;
@@ -131,7 +140,7 @@ function createOpenCodePlugin(options = {}) {
             vitePort = server.config.server.port || 5173;
             viteHost = typeof host === "string" && host !== "0.0.0.0" && host !== "::" && host !== "::1" ? host : "localhost";
           }
-          const viteOrigin = `http://${viteHost}:${vitePort}`;
+          viteOrigin = `http://${viteHost}:${vitePort}`;
           const contextApiUrl = `http://${viteHost}:${vitePort}${CONTEXT_API_PATH}`;
           log.debug("Vite server ready", {
             vitePort,
@@ -170,7 +179,7 @@ function createOpenCodePlugin(options = {}) {
         open: config.open,
         autoReload: config.autoReload,
         cwd: process.cwd(),
-        sessionUrl: service.sessionUrl || void 0,
+        // 不再注入 sessionUrl，客户端完全依赖 SSE 状态同步
         hotkey: config.hotkey
       });
       timer.end();