vite-plugin-opencode-assistant 1.0.4 → 1.0.5

package/lib/endpoints/context.js

@@ -0,0 +1,137 @@
+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 __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 context_exports = {};
+__export(context_exports, {
+  setupContextEndpoint: () => setupContextEndpoint
+});
+module.exports = __toCommonJS(context_exports);
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+var import_shared2 = require("@vite-plugin-opencode-assistant/shared");
+const log = (0, import_shared2.createLogger)("Endpoints:Context");
+function setupContextEndpoint(server, ctx) {
+  server.middlewares.use(import_shared.CONTEXT_API_PATH, (req, res) => __async(null, null, function* () {
+    const reqCtx = new import_shared2.RequestContext(req.method || "GET", import_shared.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);
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupContextEndpoint
+});

package/lib/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/lib/endpoints/index.js

@@ -0,0 +1,41 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var endpoints_exports = {};
+__export(endpoints_exports, {
+  setupMiddlewares: () => setupMiddlewares
+});
+module.exports = __toCommonJS(endpoints_exports);
+var import_widget = require("./widget.js");
+var import_context = require("./context.js");
+var import_start = require("./start.js");
+var import_sse = require("./sse.js");
+var import_sessions = require("./sessions.js");
+__reExport(endpoints_exports, require("./types.js"), module.exports);
+function setupMiddlewares(server, ctx) {
+  (0, import_widget.setupWidgetEndpoints)(server, ctx);
+  (0, import_context.setupContextEndpoint)(server, ctx);
+  (0, import_start.setupStartEndpoint)(server, ctx);
+  (0, import_sse.setupSseEndpoint)(server, ctx);
+  (0, import_sessions.setupSessionsEndpoint)(server, ctx);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupMiddlewares,
+  ...require("./types.js")
+});

package/lib/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/lib/endpoints/sessions.js

@@ -0,0 +1,102 @@
+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 __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 sessions_exports = {};
+__export(sessions_exports, {
+  setupSessionsEndpoint: () => setupSessionsEndpoint
+});
+module.exports = __toCommonJS(sessions_exports);
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+var import_shared2 = require("@vite-plugin-opencode-assistant/shared");
+const log = (0, import_shared2.createLogger)("Endpoints:Sessions");
+function setupSessionsEndpoint(server, ctx) {
+  server.middlewares.use(import_shared.SESSIONS_API_PATH, (req, res) => __async(null, null, function* () {
+    const reqCtx = new import_shared2.RequestContext(req.method || "GET", import_shared.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);
+    }
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupSessionsEndpoint
+});

package/lib/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/lib/endpoints/sse.js

@@ -0,0 +1,79 @@
+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 __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 sse_exports = {};
+__export(sse_exports, {
+  setupSseEndpoint: () => setupSseEndpoint
+});
+module.exports = __toCommonJS(sse_exports);
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+var import_shared2 = require("@vite-plugin-opencode-assistant/shared");
+const log = (0, import_shared2.createLogger)("Endpoints:SSE");
+function setupSseEndpoint(server, ctx) {
+  server.middlewares.use(import_shared.SSE_EVENTS_PATH, (req, res) => __async(null, null, function* () {
+    const reqCtx = new import_shared2.RequestContext("GET", import_shared.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);
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupSseEndpoint
+});

package/lib/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/lib/endpoints/start.js

@@ -0,0 +1,58 @@
+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 __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 start_exports = {};
+__export(start_exports, {
+  setupStartEndpoint: () => setupStartEndpoint
+});
+module.exports = __toCommonJS(start_exports);
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+var import_shared2 = require("@vite-plugin-opencode-assistant/shared");
+function setupStartEndpoint(server, ctx) {
+  server.middlewares.use(import_shared.START_API_PATH, (_req, res) => __async(null, null, function* () {
+    const reqCtx = new import_shared2.RequestContext("GET", import_shared.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);
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupStartEndpoint
+});

package/lib/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/lib/endpoints/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/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/lib/endpoints/widget.js

@@ -0,0 +1,90 @@
+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 __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 __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 widget_exports = {};
+__export(widget_exports, {
+  setupWidgetEndpoints: () => setupWidgetEndpoints
+});
+module.exports = __toCommonJS(widget_exports);
+var import_fs = __toESM(require("fs"));
+var import_shared = require("@vite-plugin-opencode-assistant/shared");
+var import_shared2 = require("@vite-plugin-opencode-assistant/shared");
+function setupWidgetEndpoints(server, ctx) {
+  server.middlewares.use(import_shared.WIDGET_SCRIPT_PATH, (_req, res) => __async(null, null, function* () {
+    const reqCtx = new import_shared2.RequestContext("GET", import_shared.WIDGET_SCRIPT_PATH);
+    const widgetPath = ctx.resolveWidgetPath();
+    if (import_fs.default.existsSync(widgetPath)) {
+      res.setHeader("Content-Type", "application/javascript");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      import_fs.default.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 import_shared2.RequestContext("GET", WIDGET_STYLE_PATH);
+    const stylePath = ctx.resolveWidgetStylePath();
+    if (import_fs.default.existsSync(stylePath)) {
+      res.setHeader("Content-Type", "text/css");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      import_fs.default.createReadStream(stylePath).pipe(res);
+      reqCtx.end(200);
+    } else {
+      res.writeHead(404);
+      res.end("Widget style not found");
+      reqCtx.end(404);
+    }
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupWidgetEndpoints
+});

package/lib/index.d.ts

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