vite-plugin-opencode-assistant 1.0.13 → 1.0.15

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();

package/es/utils/system.d.ts

@@ -1,4 +1,5 @@
-export declare function waitForServer(url: string, timeout?: number): Promise<void>;
+import type { ResultPromise } from "execa";
+export declare function waitForServer(url: string, timeout?: number, process?: ResultPromise): Promise<void>;
 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>;

package/es/utils/system.js

@@ -21,14 +21,10 @@ var __async = (__this, __arguments, generator) => {
 import { spawn } from "child_process";
 import http from "http";
 import net from "net";
-import {
-  DEFAULT_HOSTNAME,
-  MAX_PORT_TRIES,
-  SERVER_CHECK_INTERVAL
-} from "@vite-plugin-opencode-assistant/shared";
+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");
-function waitForServer(url, timeout = 1e4) {
+function waitForServer(url, timeout = 1e4, process2) {
   const timer = new PerformanceTimer("waitForServer", { url, timeout });
   return new Promise((resolve, reject) => {
     const startTime = Date.now();
@@ -36,6 +32,11 @@ function waitForServer(url, timeout = 1e4) {
     const check = () => {
       attempts++;
       log.debug(`Checking server availability (attempt ${attempts})`, { url });
+      if ((process2 == null ? void 0 : process2.exitCode) !== null && (process2 == null ? void 0 : process2.exitCode) !== void 0) {
+        timer.end(`\u274C Process exited with code ${process2.exitCode}`);
+        reject(new Error(`Process exited with code ${process2.exitCode}`));
+        return;
+      }
       const req = http.get(url, (res) => {
         if (res.statusCode && res.statusCode < 500) {
           timer.end(`\u2713 Server ready after ${attempts} attempts`);
@@ -81,8 +82,8 @@ function checkOpenCodeInstalled() {
     });
   });
 }
-function isPortAvailable(_0) {
-  return __async(this, arguments, function* (port, hostname = DEFAULT_HOSTNAME) {
+function isPortAvailable(port, hostname) {
+  return __async(this, null, function* () {
     return new Promise((resolve) => {
       const server = net.createServer();
       server.once("error", (err) => {
@@ -98,8 +99,8 @@ function isPortAvailable(_0) {
     });
   });
 }
-function findAvailablePort(_0) {
-  return __async(this, arguments, function* (startPort, hostname = DEFAULT_HOSTNAME, maxTries = MAX_PORT_TRIES) {
+function findAvailablePort(_0, _1) {
+  return __async(this, arguments, function* (startPort, hostname, maxTries = MAX_PORT_TRIES) {
     const timer = log.timer("findAvailablePort", { startPort, hostname, maxTries });
     log.debug(`Looking for available port starting from ${startPort}`);
     for (let port = startPort; port < startPort + maxTries; port++) {