vite-plugin-opencode-assistant 1.0.4 → 1.0.6

package/es/core/service.js

@@ -0,0 +1,163 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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 { prepareOpenCodeRuntime, startOpenCodeWeb } from "@vite-plugin-opencode-assistant/opencode";
+import { SERVER_START_TIMEOUT, createLogger } from "@vite-plugin-opencode-assistant/shared";
+import {
+  checkOpenCodeInstalled,
+  findAvailablePort,
+  killOrphanOpenCodeProcesses,
+  waitForServer
+} from "../utils/system.js";
+const log = createLogger("Service");
+class OpenCodeService {
+  constructor(config, api, sseClients, onPortAllocated) {
+    __publicField(this, "config", config);
+    __publicField(this, "api", api);
+    __publicField(this, "sseClients", sseClients);
+    __publicField(this, "onPortAllocated", onPortAllocated);
+    __publicField(this, "webProcess", null);
+    __publicField(this, "actualWebPort");
+    __publicField(this, "isStarted", false);
+    __publicField(this, "startPromise", null);
+    __publicField(this, "sessionUrl", null);
+    this.actualWebPort = config.webPort;
+  }
+  start(corsOrigins, contextApiUrl, viteOrigin) {
+    return __async(this, null, function* () {
+      if (this.isStarted && this.webProcess) {
+        log.debug("Services already started, skipping");
+        return;
+      }
+      if (this.startPromise) {
+        log.debug("Waiting for existing start promise");
+        return this.startPromise;
+      }
+      this.startPromise = (() => __async(this, null, function* () {
+        const timer = log.timer("startServices", {
+          corsOrigins,
+          contextApiUrl,
+          viteOrigin
+        });
+        log.info("Starting OpenCode services...");
+        const orphanCount = yield killOrphanOpenCodeProcesses();
+        if (orphanCount > 0) {
+          log.debug(`Killed ${orphanCount} orphan OpenCode process(es)`);
+        }
+        if (!(yield checkOpenCodeInstalled())) {
+          log.error(`OpenCode is not installed!
+
+Please install OpenCode first:
+
+  # YOLO
+  curl -fsSL https://opencode.ai/install | bash
+
+  # Package managers
+  npm i -g opencode-ai@latest        # or bun/pnpm/yarn
+  scoop install opencode             # Windows
+  choco install opencode             # Windows
+  brew install anomalyco/tap/opencode # macOS and Linux (recommended, always up to date)
+  brew install opencode              # macOS and Linux (official brew formula, updated less)
+  sudo pacman -S opencode            # Arch Linux (Stable)
+  paru -S opencode-bin               # Arch Linux (Latest from AUR)
+  mise use -g opencode               # Any OS
+  nix run nixpkgs#opencode           # or github:anomalyco/opencode for latest dev branch
+        `);
+          timer.end("\u274C OpenCode not installed");
+          return;
+        }
+        timer.checkpoint("OpenCode installation verified");
+        this.actualWebPort = yield findAvailablePort(this.config.webPort, this.config.hostname);
+        this.onPortAllocated(this.actualWebPort);
+        if (this.actualWebPort !== this.config.webPort) {
+          log.info(`Port ${this.config.webPort} is in use, using ${this.actualWebPort} instead`);
+        } else {
+          log.debug(`Using port ${this.actualWebPort}`);
+        }
+        timer.checkpoint("Port allocated");
+        const configDir = prepareOpenCodeRuntime(process.cwd());
+        timer.checkpoint("Plugin setup complete");
+        log.debug("Starting OpenCode Web process...", {
+          port: this.actualWebPort,
+          hostname: this.config.hostname,
+          configDir
+        });
+        this.webProcess = startOpenCodeWeb({
+          port: this.actualWebPort,
+          hostname: this.config.hostname,
+          serverUrl: "",
+          cwd: process.cwd(),
+          configDir,
+          corsOrigins,
+          contextApiUrl
+        });
+        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}`);
+        yield this.api.warmupChromeMcp(viteOrigin);
+        timer.checkpoint("Chrome MCP warmup complete");
+        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 });
+        }
+        this.isStarted = true;
+        log.debug(`OpenCode services started successfully: ${this.sessionUrl || webUrl}`);
+        timer.end("\u2713 Services started successfully");
+      }))();
+      return this.startPromise;
+    });
+  }
+  stop() {
+    return __async(this, null, function* () {
+      const timer = log.timer("stopServices");
+      log.info("Stopping OpenCode services...");
+      if (this.webProcess) {
+        log.debug("Killing web process", { pid: this.webProcess.pid });
+        this.webProcess.kill("SIGTERM");
+        this.webProcess = null;
+      }
+      this.isStarted = false;
+      this.startPromise = null;
+      timer.end("\u2713 Services stopped");
+    });
+  }
+}
+export {
+  OpenCodeService
+};

package/es/endpoints/context.d.ts

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

package/es/endpoints/context.js

@@ -0,0 +1,114 @@
+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 { CONTEXT_API_PATH } from "@vite-plugin-opencode-assistant/shared";
+import { RequestContext, createLogger } from "@vite-plugin-opencode-assistant/shared";
+const log = createLogger("Endpoints:Context");
+function setupContextEndpoint(server, ctx) {
+  server.middlewares.use(CONTEXT_API_PATH, (req, res) => __async(null, null, function* () {
+    const reqCtx = new RequestContext(req.method || "GET", CONTEXT_API_PATH);
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      reqCtx.end(200);
+      return;
+    }
+    if (req.method === "GET") {
+      res.writeHead(200);
+      res.end(JSON.stringify(ctx.pageContext));
+      reqCtx.end(200);
+      return;
+    }
+    if (req.method === "DELETE") {
+      ctx.pageContext.selectedElements = [];
+      log.debug("Selected elements cleared", { sseClients: ctx.sseClients.size });
+      let sentCount = 0;
+      ctx.sseClients.forEach((client) => {
+        try {
+          client.write(`data: ${JSON.stringify({ type: "CLEAR_ELEMENTS" })}
+
+`);
+          sentCount++;
+        } catch (e) {
+          log.debug("Failed to send SSE message", { error: e });
+        }
+      });
+      log.debug("SSE messages sent", {
+        count: sentCount,
+        totalClients: ctx.sseClients.size
+      });
+      res.writeHead(200);
+      res.end(JSON.stringify({ success: true }));
+      reqCtx.end(200);
+      return;
+    }
+    if (req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      req.on("end", () => {
+        var _a;
+        try {
+          const data = JSON.parse(body);
+          ctx.pageContext = {
+            url: data.url || "",
+            title: data.title || "",
+            selectedElements: data.selectedElements || []
+          };
+          log.debug("Context updated", {
+            url: ctx.pageContext.url,
+            title: ctx.pageContext.title,
+            selectedElementsCount: ((_a = ctx.pageContext.selectedElements) == null ? void 0 : _a.length) || 0
+          });
+          if (ctx.pageContext.selectedElements && ctx.pageContext.selectedElements.length > 0) {
+            log.debug("Selected elements details", {
+              elements: ctx.pageContext.selectedElements.map((el) => {
+                var _a2;
+                return {
+                  filePath: el.filePath,
+                  line: el.line,
+                  text: (_a2 = el.innerText) == null ? void 0 : _a2.substring(0, 50)
+                };
+              })
+            });
+          }
+          res.writeHead(200);
+          res.end(JSON.stringify({ success: true }));
+          reqCtx.end(200);
+        } catch (e) {
+          log.debug("Invalid JSON in request body", { error: e });
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: "Invalid JSON" }));
+          reqCtx.error(e);
+        }
+      });
+      return;
+    }
+    res.writeHead(405);
+    res.end(JSON.stringify({ error: "Method not allowed" }));
+    reqCtx.end(405);
+  }));
+}
+export {
+  setupContextEndpoint
+};

package/es/endpoints/index.d.ts

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

package/es/endpoints/index.js

@@ -0,0 +1,16 @@
+import { setupWidgetEndpoints } from "./widget.js";
+import { setupContextEndpoint } from "./context.js";
+import { setupStartEndpoint } from "./start.js";
+import { setupSseEndpoint } from "./sse.js";
+import { setupSessionsEndpoint } from "./sessions.js";
+export * from "./types.js";
+function setupMiddlewares(server, ctx) {
+  setupWidgetEndpoints(server, ctx);
+  setupContextEndpoint(server, ctx);
+  setupStartEndpoint(server, ctx);
+  setupSseEndpoint(server, ctx);
+  setupSessionsEndpoint(server, ctx);
+}
+export {
+  setupMiddlewares
+};

package/es/endpoints/sessions.d.ts

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

package/es/endpoints/sessions.js

@@ -0,0 +1,79 @@
+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 { SESSIONS_API_PATH } from "@vite-plugin-opencode-assistant/shared";
+import { RequestContext, createLogger } from "@vite-plugin-opencode-assistant/shared";
+const log = createLogger("Endpoints:Sessions");
+function setupSessionsEndpoint(server, ctx) {
+  server.middlewares.use(SESSIONS_API_PATH, (req, res) => __async(null, null, function* () {
+    const reqCtx = new RequestContext(req.method || "GET", SESSIONS_API_PATH);
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      reqCtx.end(200);
+      return;
+    }
+    try {
+      if (req.method === "GET") {
+        reqCtx.checkpoint("Fetching sessions");
+        const sessions = yield ctx.getSessions();
+        res.writeHead(200);
+        res.end(JSON.stringify(sessions));
+        reqCtx.end(200);
+      } else if (req.method === "POST") {
+        reqCtx.checkpoint("Creating session");
+        const newSession = yield ctx.createSession();
+        res.writeHead(200);
+        res.end(JSON.stringify(newSession));
+        reqCtx.end(200);
+      } else if (req.method === "DELETE") {
+        const url = new URL(req.url || "", `http://${req.headers.host}`);
+        const sessionId = url.searchParams.get("id");
+        if (!sessionId) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: "Session ID is required" }));
+          reqCtx.end(400);
+          return;
+        }
+        reqCtx.checkpoint(`Deleting session: ${sessionId}`);
+        yield ctx.deleteSession(sessionId);
+        res.writeHead(200);
+        res.end(JSON.stringify({ success: true }));
+        reqCtx.end(200);
+      } else {
+        res.writeHead(405);
+        res.end(JSON.stringify({ error: "Method not allowed" }));
+        reqCtx.end(405);
+      }
+    } catch (e) {
+      log.error("Session API error", { error: e, method: req.method });
+      res.writeHead(500);
+      res.end(JSON.stringify({ error: String(e) }));
+      reqCtx.error(e);
+    }
+  }));
+}
+export {
+  setupSessionsEndpoint
+};

package/es/endpoints/sse.d.ts

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

package/es/endpoints/sse.js

@@ -0,0 +1,56 @@
+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 { SSE_EVENTS_PATH } from "@vite-plugin-opencode-assistant/shared";
+import { RequestContext, createLogger } from "@vite-plugin-opencode-assistant/shared";
+const log = createLogger("Endpoints:SSE");
+function setupSseEndpoint(server, ctx) {
+  server.middlewares.use(SSE_EVENTS_PATH, (req, res) => __async(null, null, function* () {
+    const reqCtx = new RequestContext("GET", SSE_EVENTS_PATH);
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    });
+    ctx.sseClients.add(res);
+    log.debug("SSE client connected", { totalClients: ctx.sseClients.size });
+    res.write(`data: ${JSON.stringify({ type: "CONNECTED" })}
+
+`);
+    if (ctx.sessionUrl) {
+      res.write(
+        `data: ${JSON.stringify({ type: "SESSION_READY", sessionUrl: ctx.sessionUrl })}
+
+`
+      );
+    }
+    req.on("close", () => {
+      ctx.sseClients.delete(res);
+      log.debug("SSE client disconnected", {
+        totalClients: ctx.sseClients.size
+      });
+    });
+    reqCtx.end(200);
+  }));
+}
+export {
+  setupSseEndpoint
+};

package/es/endpoints/start.d.ts

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

package/es/endpoints/start.js

@@ -0,0 +1,35 @@
+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 { START_API_PATH } from "@vite-plugin-opencode-assistant/shared";
+import { RequestContext } from "@vite-plugin-opencode-assistant/shared";
+function setupStartEndpoint(server, ctx) {
+  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 }));
+    reqCtx.end(200);
+  }));
+}
+export {
+  setupStartEndpoint
+};

package/es/endpoints/types.d.ts

@@ -0,0 +1,13 @@
+import type { PageContext, SessionInfo } from "@vite-plugin-opencode-assistant/shared";
+import type http from "http";
+export interface EndpointContext {
+    get sessionUrl(): string | null;
+    get sseClients(): Set<http.ServerResponse>;
+    get pageContext(): PageContext;
+    set pageContext(ctx: PageContext);
+    getSessions: () => Promise<SessionInfo[]>;
+    createSession: () => Promise<SessionInfo>;
+    deleteSession: (id: string) => Promise<void>;
+    resolveWidgetPath: () => string;
+    resolveWidgetStylePath: () => string;
+}

package/es/endpoints/widget.d.ts

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

package/es/endpoints/widget.js

@@ -0,0 +1,57 @@
+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 fs from "fs";
+import { WIDGET_SCRIPT_PATH } from "@vite-plugin-opencode-assistant/shared";
+import { RequestContext } from "@vite-plugin-opencode-assistant/shared";
+function setupWidgetEndpoints(server, ctx) {
+  server.middlewares.use(WIDGET_SCRIPT_PATH, (_req, res) => __async(null, null, function* () {
+    const reqCtx = new RequestContext("GET", WIDGET_SCRIPT_PATH);
+    const widgetPath = ctx.resolveWidgetPath();
+    if (fs.existsSync(widgetPath)) {
+      res.setHeader("Content-Type", "application/javascript");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      fs.createReadStream(widgetPath).pipe(res);
+      reqCtx.end(200);
+    } else {
+      res.writeHead(404);
+      res.end("Widget script not found");
+      reqCtx.end(404);
+    }
+  }));
+  const WIDGET_STYLE_PATH = "/__opencode_widget__.css";
+  server.middlewares.use(WIDGET_STYLE_PATH, (_req, res) => __async(null, null, function* () {
+    const reqCtx = new RequestContext("GET", WIDGET_STYLE_PATH);
+    const stylePath = ctx.resolveWidgetStylePath();
+    if (fs.existsSync(stylePath)) {
+      res.setHeader("Content-Type", "text/css");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      fs.createReadStream(stylePath).pipe(res);
+      reqCtx.end(200);
+    } else {
+      res.writeHead(404);
+      res.end("Widget style not found");
+      reqCtx.end(404);
+    }
+  }));
+}
+export {
+  setupWidgetEndpoints
+};

package/{dist/vite → es}/index.d.ts

@@ -1,3 +1,3 @@
 import type { Plugin } from "vite";
-import { OpenCodeOptions } from "../types.js";
+import type { OpenCodeOptions } from "@vite-plugin-opencode-assistant/shared";
 export default function opencodePlugin(options?: OpenCodeOptions): Plugin[];