vite-plugin-opencode-assistant 1.0.3 → 1.0.5

package/lib/core/api.d.ts

@@ -0,0 +1,14 @@
+import type { SessionInfo } from "@vite-plugin-opencode-assistant/shared";
+export declare class OpenCodeAPI {
+    private hostname;
+    private getPort;
+    private warmupChromeMcpConfig;
+    constructor(hostname: string, getPort: () => number, warmupChromeMcpConfig?: boolean);
+    private createHttpRequest;
+    getSessions(retries?: number): Promise<SessionInfo[]>;
+    createSession(retries?: number, title?: string): Promise<SessionInfo>;
+    deleteSession(sessionId: string, retries?: number): Promise<void>;
+    getToolIds(retries?: number): Promise<string[]>;
+    warmupChromeMcp(viteOrigin?: string): Promise<void>;
+    getOrCreateSession(): Promise<string>;
+}

package/lib/core/api.js

@@ -0,0 +1,321 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var api_exports = {};
+__export(api_exports, {
+  OpenCodeAPI: () => OpenCodeAPI
+});
+module.exports = __toCommonJS(api_exports);
+var import_http = __toESM(require("http"));
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+const log = (0, import_shared.createLogger)("API");
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function base64Encode(str) {
+  return Buffer.from(str).toString("base64");
+}
+class OpenCodeAPI {
+  constructor(hostname, getPort, warmupChromeMcpConfig = false) {
+    __publicField(this, "hostname", hostname);
+    __publicField(this, "getPort", getPort);
+    __publicField(this, "warmupChromeMcpConfig", warmupChromeMcpConfig);
+  }
+  createHttpRequest(options, body) {
+    const timer = new import_shared.PerformanceTimer("HTTP Request", {
+      operation: `${options.method || "GET"} ${options.path}`
+    });
+    return new Promise((resolve, reject) => {
+      const req = import_http.default.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => data += chunk);
+        res.on("end", () => {
+          try {
+            const result = JSON.parse(data);
+            timer.end(`\u2713 Status: ${res.statusCode}`);
+            resolve(result);
+          } catch (e) {
+            timer.end("\u274C JSON parse error");
+            reject(new Error(`JSON parse error: ${data.substring(0, 100)}`));
+          }
+        });
+      });
+      req.on("error", (e) => {
+        timer.end("\u274C Request failed");
+        reject(e);
+      });
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+  getSessions() {
+    return __async(this, arguments, function* (retries = import_shared.DEFAULT_RETRIES) {
+      const timer = log.timer("getSessions", { retries });
+      let lastError = null;
+      for (let i = 0; i < retries; i++) {
+        try {
+          log.debug(`Attempt ${i + 1}/${retries}`, { operation: "getSessions" });
+          const sessions = yield this.createHttpRequest({
+            hostname: this.hostname,
+            port: this.getPort(),
+            path: "/session"
+          });
+          timer.end(`Found ${sessions.length} sessions`);
+          return sessions;
+        } catch (e) {
+          lastError = e instanceof Error ? e : new Error(String(e));
+          log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+            operation: "getSessions"
+          });
+          if (i < retries - 1) {
+            log.debug(`Retrying in ${import_shared.RETRY_DELAY}ms...`, {
+              operation: "getSessions"
+            });
+            yield sleep(import_shared.RETRY_DELAY);
+          }
+        }
+      }
+      timer.end("\u274C All retries exhausted");
+      throw lastError;
+    });
+  }
+  createSession() {
+    return __async(this, arguments, function* (retries = import_shared.DEFAULT_RETRIES, title) {
+      const timer = log.timer("createSession", { retries, title });
+      let lastError = null;
+      for (let i = 0; i < retries; i++) {
+        try {
+          log.debug(`Attempt ${i + 1}/${retries}`, {
+            operation: "createSession",
+            title
+          });
+          const requestBody = title ? JSON.stringify({ title }) : void 0;
+          const session = yield this.createHttpRequest(
+            {
+              hostname: this.hostname,
+              port: this.getPort(),
+              path: "/session",
+              method: "POST",
+              headers: requestBody ? { "Content-Type": "application/json" } : void 0
+            },
+            requestBody
+          );
+          timer.end(`Created session: ${session.id}`);
+          return session;
+        } catch (e) {
+          lastError = e instanceof Error ? e : new Error(String(e));
+          log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+            operation: "createSession"
+          });
+          if (i < retries - 1) {
+            log.debug(`Retrying in ${import_shared.RETRY_DELAY}ms...`, {
+              operation: "createSession"
+            });
+            yield sleep(import_shared.RETRY_DELAY);
+          }
+        }
+      }
+      timer.end("\u274C All retries exhausted");
+      throw lastError;
+    });
+  }
+  deleteSession(_0) {
+    return __async(this, arguments, function* (sessionId, retries = import_shared.DEFAULT_RETRIES) {
+      const timer = log.timer("deleteSession", { sessionId, retries });
+      let lastError = null;
+      for (let i = 0; i < retries; i++) {
+        try {
+          log.debug(`Attempt ${i + 1}/${retries}`, {
+            operation: "deleteSession",
+            sessionId
+          });
+          yield this.createHttpRequest({
+            hostname: this.hostname,
+            port: this.getPort(),
+            path: `/session/${sessionId}`,
+            method: "DELETE"
+          });
+          timer.end(`Deleted session: ${sessionId}`);
+          return;
+        } catch (e) {
+          lastError = e instanceof Error ? e : new Error(String(e));
+          log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+            operation: "deleteSession",
+            sessionId
+          });
+          if (i < retries - 1) {
+            log.debug(`Retrying in ${import_shared.RETRY_DELAY}ms...`, {
+              operation: "deleteSession",
+              sessionId
+            });
+            yield sleep(import_shared.RETRY_DELAY);
+          }
+        }
+      }
+      timer.end("\u274C All retries exhausted");
+      throw lastError;
+    });
+  }
+  getToolIds() {
+    return __async(this, arguments, function* (retries = import_shared.DEFAULT_RETRIES) {
+      const timer = log.timer("getToolIds", { retries });
+      let lastError = null;
+      for (let i = 0; i < retries; i++) {
+        try {
+          log.debug(`Attempt ${i + 1}/${retries}`, {
+            operation: "getToolIds"
+          });
+          const toolIds = yield this.createHttpRequest({
+            hostname: this.hostname,
+            port: this.getPort(),
+            path: "/experimental/tool/ids"
+          });
+          timer.end(`Found ${toolIds.length} tools`);
+          return toolIds;
+        } catch (e) {
+          lastError = e instanceof Error ? e : new Error(String(e));
+          log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, {
+            operation: "getToolIds"
+          });
+          if (i < retries - 1) {
+            log.debug(`Retrying in ${import_shared.RETRY_DELAY}ms...`, {
+              operation: "getToolIds"
+            });
+            yield sleep(import_shared.RETRY_DELAY);
+          }
+        }
+      }
+      timer.end("\u274C All retries exhausted");
+      throw lastError;
+    });
+  }
+  warmupChromeMcp(viteOrigin) {
+    return __async(this, null, function* () {
+      if (!this.warmupChromeMcpConfig) return;
+      const timer = log.timer("warmupChromeMcp", { viteOrigin });
+      let warmupSessionId = null;
+      try {
+        const warmupSession = yield this.createSession(import_shared.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"
+        ].join(" ");
+        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.",
+            tools: (chromeToolIds == null ? void 0 : chromeToolIds.length) ? chromeToolIds : void 0,
+            parts: [{ type: "text", text: prompt }]
+          })
+        );
+        timer.end("Chrome MCP warmed up");
+      } catch (e) {
+        log.warn("Failed to warm up Chrome MCP", { error: e });
+        timer.end("Chrome MCP warmup skipped");
+      } finally {
+        if (warmupSessionId) {
+          try {
+            yield this.deleteSession(warmupSessionId, 5);
+          } catch (e) {
+            log.warn("Failed to delete warmup session after retries", {
+              error: e,
+              warmupSessionId
+            });
+          }
+        }
+      }
+    });
+  }
+  getOrCreateSession() {
+    return __async(this, null, function* () {
+      const timer = log.timer("getOrCreateSession");
+      const projectDir = process.cwd();
+      log.debug("Getting sessions...", { projectDir });
+      const sessions = yield this.getSessions();
+      log.debug(`Found ${sessions.length} sessions`, {
+        sessions: sessions.map((s) => ({ id: s.id, directory: s.directory }))
+      });
+      const matchingSession = sessions.find((s) => s.directory === projectDir);
+      if (matchingSession) {
+        const url2 = `http://${this.hostname}:${this.getPort()}/${base64Encode(projectDir)}/session/${matchingSession.id}`;
+        timer.end(`Using existing session: ${matchingSession.id}`);
+        return url2;
+      }
+      log.debug("Creating new session...", { projectDir });
+      const newSession = yield this.createSession();
+      const url = `http://${this.hostname}:${this.getPort()}/${base64Encode(projectDir)}/session/${newSession.id}`;
+      timer.end(`Created new session: ${newSession.id}`);
+      return url;
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenCodeAPI
+});

package/lib/core/injector.d.ts

@@ -0,0 +1,2 @@
+import type { WidgetOptions } from "@vite-plugin-opencode-assistant/shared";
+export declare function injectWidget(options: WidgetOptions): string;

package/lib/core/injector.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var injector_exports = {};
+__export(injector_exports, {
+  injectWidget: () => injectWidget
+});
+module.exports = __toCommonJS(injector_exports);
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+function injectWidget(options) {
+  const configBase64 = Buffer.from(JSON.stringify(options)).toString("base64");
+  const scriptTag = `<script type="module" src="${import_shared.WIDGET_SCRIPT_PATH}" ${import_shared.CONFIG_DATA_ATTR}="${configBase64}"></script>`;
+  const styleTag = `<link rel="stylesheet" href="/__opencode_widget__.css" />`;
+  return `${styleTag}
+${scriptTag}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectWidget
+});

package/lib/core/service.d.ts

@@ -0,0 +1,18 @@
+import type { ResultPromise } from "execa";
+import type http from "http";
+import type { OpenCodeOptions } from "@vite-plugin-opencode-assistant/shared";
+import type { OpenCodeAPI } from "./api.js";
+export declare class OpenCodeService {
+    private config;
+    private api;
+    private sseClients;
+    private onPortAllocated;
+    webProcess: ResultPromise | null;
+    actualWebPort: number;
+    isStarted: boolean;
+    private startPromise;
+    sessionUrl: string | null;
+    constructor(config: Required<OpenCodeOptions>, api: OpenCodeAPI, sseClients: Set<http.ServerResponse>, onPortAllocated: (port: number) => void);
+    start(corsOrigins?: string[], contextApiUrl?: string, viteOrigin?: string): Promise<void>;
+    stop(): Promise<void>;
+}

package/lib/core/service.js

@@ -0,0 +1,180 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var service_exports = {};
+__export(service_exports, {
+  OpenCodeService: () => OpenCodeService
+});
+module.exports = __toCommonJS(service_exports);
+var import_opencode = require("@vite-plugin-opencode-assistant/opencode");
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+var import_system = require("../utils/system.js");
+const log = (0, import_shared.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 (0, import_system.killOrphanOpenCodeProcesses)();
+        if (orphanCount > 0) {
+          log.debug(`Killed ${orphanCount} orphan OpenCode process(es)`);
+        }
+        if (!(yield (0, import_system.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 (0, import_system.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 = (0, import_opencode.prepareOpenCodeRuntime)(process.cwd());
+        timer.checkpoint("Plugin setup complete");
+        log.debug("Starting OpenCode Web process...", {
+          port: this.actualWebPort,
+          hostname: this.config.hostname,
+          configDir
+        });
+        this.webProcess = (0, import_opencode.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 (0, import_system.waitForServer)(webUrl, import_shared.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");
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenCodeService
+});

package/lib/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;