vite-plugin-opencode-assistant 1.0.13 → 1.0.15

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/proxy-server.d.ts

@@ -8,4 +8,8 @@ export interface ProxyServerOptions {
     /** OpenCode 内部设置 */
     settings?: OpenCodeSettings;
 }
-export declare function startProxyServer(targetUrl: string, port: number, options?: ProxyServerOptions): http.Server;
+export interface ProxyServerResult {
+    server: http.Server;
+    actualPort: number;
+}
+export declare function startProxyServer(targetUrl: string, port: number, options?: ProxyServerOptions): Promise<ProxyServerResult>;

package/es/core/proxy-server.js

@@ -114,80 +114,86 @@ function generateBridgeScript(options) {
 `;
 }
 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);
+  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)
         });
-        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);
+        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"
+        })
+      };
+      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");
+      });
+      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.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,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) {
@@ -64,7 +92,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,
@@ -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,53 +159,119 @@ 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.actualProxyPort = yield findAvailablePort(
-          (_a = this.config.proxyPort) != null ? _a : DEFAULT_PROXY_PORT,
-          this.config.hostname
-        );
+        this.sendTaskUpdate("waiting_web_ready");
+        try {
+          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 });
+          this.sendTaskUpdate("web_start_timeout");
+          this.startPromise = null;
+          timer.end("\u274C Web start timeout");
+          return;
+        }
+        this.sendTaskUpdate("starting_proxy");
+        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");
-        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;