vite-plugin-opencode-assistant 1.0.4 → 1.0.5

package/es/index.js

@@ -0,0 +1,168 @@
+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 __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 Inspector from "unplugin-vue-inspector/vite";
+import {
+  CONTEXT_API_PATH,
+  DEFAULT_CONFIG,
+  createLogger,
+  setVerbose
+} from "@vite-plugin-opencode-assistant/shared";
+import { setupMiddlewares } from "./endpoints/index.js";
+import { injectWidget } from "./core/injector.js";
+import { OpenCodeAPI } from "./core/api.js";
+import { OpenCodeService } from "./core/service.js";
+import { resolveWidgetPath, resolveWidgetStylePath } from "./utils/paths.js";
+function opencodePlugin(options = {}) {
+  const plugins = [];
+  plugins.push(
+    ...Inspector({
+      enabled: false,
+      toggleButtonVisibility: "never",
+      toggleComboKey: false
+    })
+  );
+  plugins.push(createOpenCodePlugin(options));
+  return plugins;
+}
+function createOpenCodePlugin(options = {}) {
+  const config = __spreadValues(__spreadValues({}, DEFAULT_CONFIG), options);
+  setVerbose(config.verbose);
+  const log = createLogger("Plugin");
+  let actualWebPort = config.webPort;
+  let pageContext = { url: "", title: "" };
+  const sseClients = /* @__PURE__ */ new Set();
+  const api = new OpenCodeAPI(config.hostname, () => actualWebPort, config.warmupChromeMcp);
+  const service = new OpenCodeService(config, api, sseClients, (port) => {
+    actualWebPort = port;
+  });
+  return {
+    name: "vite-plugin-opencode",
+    apply(_viteConfig, env) {
+      if (!config.enabled) return false;
+      return env.command === "serve" && process.env.NODE_ENV !== "test";
+    },
+    configureServer(server) {
+      return __async(this, null, function* () {
+        var _a2, _b;
+        const timer = log.timer("configureServer");
+        setupMiddlewares(server, {
+          get sessionUrl() {
+            return service.sessionUrl;
+          },
+          get sseClients() {
+            return sseClients;
+          },
+          get pageContext() {
+            return pageContext;
+          },
+          set pageContext(ctx) {
+            pageContext = ctx;
+          },
+          getSessions: () => api.getSessions(),
+          createSession: () => api.createSession(),
+          deleteSession: (id) => api.deleteSession(id),
+          resolveWidgetPath,
+          resolveWidgetStylePath
+        });
+        (_a2 = server.httpServer) == null ? void 0 : _a2.on("listening", () => __async(null, null, function* () {
+          var _a3;
+          log.debug("Vite server listening event fired");
+          const address = (_a3 = server.httpServer) == null ? void 0 : _a3.address();
+          let vitePort;
+          let viteHost;
+          if (address && typeof address === "object") {
+            vitePort = address.port;
+            const addr = address.address;
+            if (addr === "::" || addr === "::1" || addr === "0.0.0.0" || !addr) {
+              viteHost = "localhost";
+            } else {
+              viteHost = addr;
+            }
+          } else {
+            const host = server.config.server.host;
+            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}`;
+          const contextApiUrl = `http://${viteHost}:${vitePort}${CONTEXT_API_PATH}`;
+          log.debug("Vite server ready", {
+            vitePort,
+            viteHost,
+            viteOrigin,
+            contextApiUrl
+          });
+          try {
+            yield service.start([viteOrigin], contextApiUrl, viteOrigin);
+          } catch (e) {
+            log.error("Failed to start services", { error: e });
+          }
+        }));
+        (_b = server.httpServer) == null ? void 0 : _b.on("close", () => {
+          log.debug("HTTP server closing");
+          service.stop();
+        });
+        const cleanup = () => __async(null, null, function* () {
+          log.debug("Process cleanup triggered");
+          yield service.stop();
+          process.exit(0);
+        });
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        timer.end("\u2713 Server configured");
+      });
+    },
+    transformIndexHtml(html) {
+      const timer = log.timer("transformIndexHtml");
+      const widget = injectWidget({
+        webUrl: `http://${config.hostname}:${actualWebPort}`,
+        serverUrl: `http://${config.hostname}:${actualWebPort}`,
+        position: config.position,
+        theme: config.theme,
+        open: config.open,
+        autoReload: config.autoReload,
+        cwd: process.cwd(),
+        sessionUrl: service.sessionUrl || void 0,
+        hotkey: config.hotkey
+      });
+      timer.end();
+      return html.replace("</body>", `${widget}</body>`);
+    }
+  };
+}
+export {
+  opencodePlugin as default
+};

package/es/utils/paths.d.ts

@@ -0,0 +1,3 @@
+export declare function resolvePackageDir(): string;
+export declare function resolveWidgetPath(): string;
+export declare function resolveWidgetStylePath(): string;

package/es/utils/paths.js

@@ -0,0 +1,38 @@
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+const require2 = createRequire(path.join(process.cwd(), "package.json"));
+const packageDir = resolvePackageDir();
+function resolvePackageDir() {
+  const entryPath = require2.resolve("vite-plugin-opencode-assistant");
+  return path.resolve(path.dirname(entryPath), "..");
+}
+function resolveWidgetPath() {
+  const candidatePaths = [
+    path.join(packageDir, "es", "client.js"),
+    path.join(packageDir, "lib", "client.js")
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (fs.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return candidatePaths[0];
+}
+function resolveWidgetStylePath() {
+  const candidatePaths = [
+    path.join(packageDir, "es", "style.css"),
+    path.join(packageDir, "lib", "style.css")
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (fs.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return candidatePaths[0];
+}
+export {
+  resolvePackageDir,
+  resolveWidgetPath,
+  resolveWidgetStylePath
+};

package/es/utils/system.js

@@ -0,0 +1,241 @@
+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 { 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 { PerformanceTimer, createLogger } from "@vite-plugin-opencode-assistant/shared";
+const log = createLogger("Utils");
+function waitForServer(url, timeout = 1e4) {
+  const timer = new PerformanceTimer("waitForServer", { url, timeout });
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    let attempts = 0;
+    const check = () => {
+      attempts++;
+      log.debug(`Checking server availability (attempt ${attempts})`, { url });
+      const req = http.get(url, (res) => {
+        if (res.statusCode && res.statusCode < 500) {
+          timer.end(`\u2713 Server ready after ${attempts} attempts`);
+          resolve();
+        } else {
+          log.debug(`Server returned status ${res.statusCode}, retrying...`);
+          retryOrReject();
+        }
+      });
+      req.on("error", (err) => {
+        log.debug(`Server check failed: ${err.message}`);
+        retryOrReject();
+      });
+    };
+    const retryOrReject = () => {
+      const elapsed = Date.now() - startTime;
+      if (elapsed < timeout) {
+        setTimeout(check, SERVER_CHECK_INTERVAL);
+      } else {
+        timer.end("\u274C Timeout");
+        reject(new Error(`Server not ready after ${timeout}ms (${attempts} attempts)`));
+      }
+    };
+    check();
+  });
+}
+function checkOpenCodeInstalled() {
+  return __async(this, null, function* () {
+    const timer = log.timer("checkOpenCodeInstalled");
+    return new Promise((resolve) => {
+      log.debug("Checking if OpenCode is installed...");
+      const proc = spawn("opencode", ["--version"], { stdio: "ignore" });
+      proc.on("close", (code) => {
+        const installed = code === 0;
+        timer.end(installed ? "\u2713 OpenCode is installed" : "\u274C OpenCode not found");
+        resolve(installed);
+      });
+      proc.on("error", (err) => {
+        log.debug("Failed to check OpenCode installation", { error: err.message });
+        timer.end("\u274C Check failed");
+        resolve(false);
+      });
+    });
+  });
+}
+function isPortAvailable(_0) {
+  return __async(this, arguments, function* (port, hostname = DEFAULT_HOSTNAME) {
+    return new Promise((resolve) => {
+      const server = net.createServer();
+      server.once("error", (err) => {
+        log.debug(`Port ${port} is not available`, { error: err.message });
+        resolve(false);
+      });
+      server.once("listening", () => {
+        server.close();
+        log.debug(`Port ${port} is available`);
+        resolve(true);
+      });
+      server.listen(port, hostname);
+    });
+  });
+}
+function findAvailablePort(_0) {
+  return __async(this, arguments, function* (startPort, hostname = DEFAULT_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++) {
+      if (yield isPortAvailable(port, hostname)) {
+        timer.end(`\u2713 Found available port: ${port}`);
+        return port;
+      }
+      log.debug(`Port ${port} is in use, trying next...`);
+    }
+    timer.end("\u274C No available port found");
+    throw new Error(`No available port found after ${maxTries} tries starting from ${startPort}`);
+  });
+}
+function killOrphanOpenCodeProcesses() {
+  return __async(this, null, function* () {
+    const timer = log.timer("killOrphanOpenCodeProcesses");
+    log.debug("Looking for orphan OpenCode processes (PPID=1)");
+    return new Promise((resolve) => {
+      if (process.platform === "win32") {
+        killOrphanProcessesOnWindows(resolve, timer);
+      } else {
+        killOrphanProcessesOnUnix(resolve, timer);
+      }
+    });
+  });
+}
+function killOrphanProcessesOnWindows(resolve, timer) {
+  var _a;
+  log.debug("Using Windows method to find orphan processes");
+  const proc = spawn(
+    "wmic",
+    ["process", "where", 'name="opencode.exe"', "get", "processid,parentprocessid"],
+    { stdio: "pipe" }
+  );
+  let output = "";
+  (_a = proc.stdout) == null ? void 0 : _a.on("data", (data) => {
+    output += data.toString();
+  });
+  proc.on("close", () => {
+    const lines = output.split("\n").filter((line) => line.trim());
+    const pidsToKill = [];
+    lines.forEach((line) => {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 2) {
+        const ppid = parts[0];
+        const pid = parts[1];
+        if (ppid === "1" && pid && !isNaN(Number(pid))) {
+          pidsToKill.push(pid);
+        }
+      }
+    });
+    if (pidsToKill.length > 0) {
+      log.debug(`Found ${pidsToKill.length} orphan processes`, { pids: pidsToKill });
+      let killedCount = 0;
+      let completedCount = 0;
+      pidsToKill.forEach((pid) => {
+        const killProc = spawn("taskkill", ["/F", "/PID", pid], { stdio: "ignore" });
+        killProc.on("close", (code) => {
+          completedCount++;
+          if (code === 0) {
+            killedCount++;
+            log.debug(`Killed orphan process ${pid}`);
+          }
+          if (completedCount === pidsToKill.length) {
+            timer.end(`\u2713 Killed ${killedCount} orphan processes`);
+            resolve(killedCount);
+          }
+        });
+      });
+    } else {
+      log.debug("No orphan processes found");
+      timer.end("No orphan processes found");
+      resolve(0);
+    }
+  });
+  proc.on("error", (err) => {
+    log.debug("Failed to find orphan processes", { error: err.message });
+    timer.end("\u274C Failed to find orphan processes");
+    resolve(0);
+  });
+}
+function killOrphanProcessesOnUnix(resolve, timer) {
+  var _a;
+  log.debug("Using Unix method to find orphan processes");
+  const proc = spawn("ps", ["-e", "-o", "pid,ppid,comm"], { stdio: "pipe" });
+  let output = "";
+  (_a = proc.stdout) == null ? void 0 : _a.on("data", (data) => {
+    output += data.toString();
+  });
+  proc.on("close", () => {
+    const lines = output.split("\n");
+    const pidsToKill = [];
+    lines.forEach((line) => {
+      const trimmed = line.trim();
+      if (trimmed.includes("opencode")) {
+        const parts = trimmed.split(/\s+/);
+        if (parts.length >= 3) {
+          const pid = parts[0];
+          const ppid = parts[1];
+          const comm = parts.slice(2).join(" ");
+          if (ppid === "1" && comm.includes("opencode")) {
+            pidsToKill.push(pid);
+          }
+        }
+      }
+    });
+    if (pidsToKill.length > 0) {
+      log.debug(`Found ${pidsToKill.length} orphan processes`, { pids: pidsToKill });
+      const killProc = spawn("kill", ["-9", ...pidsToKill], { stdio: "ignore" });
+      killProc.on("close", (code) => {
+        const killedCount = code === 0 ? pidsToKill.length : 0;
+        timer.end(
+          killedCount > 0 ? `\u2713 Killed ${killedCount} orphan processes` : "\u274C Failed to kill processes"
+        );
+        resolve(killedCount);
+      });
+      killProc.on("error", () => {
+        timer.end("\u274C Failed to kill processes");
+        resolve(0);
+      });
+    } else {
+      log.debug("No orphan processes found");
+      timer.end("No orphan processes found");
+      resolve(0);
+    }
+  });
+  proc.on("error", (err) => {
+    log.debug("Failed to find orphan processes", { error: err.message });
+    timer.end("\u274C Failed to find orphan processes");
+    resolve(0);
+  });
+}
+export {
+  checkOpenCodeInstalled,
+  findAvailablePort,
+  isPortAvailable,
+  killOrphanOpenCodeProcesses,
+  waitForServer
+};

package/lib/client/index.d.ts

@@ -0,0 +1 @@
+import "@vite-plugin-opencode-assistant/components/style.css";