vite-plugin-aipanel 1.2.0-beta.0

package/lib/endpoints/context.cjs

@@ -0,0 +1,129 @@
+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 context_exports = {};
+__export(context_exports, {
+  setupContextEndpoint: () => setupContextEndpoint
+});
+module.exports = __toCommonJS(context_exports);
+var import_core = require("@aipanel/core");
+var import_node = require("@aipanel/core/node");
+const log = (0, import_node.createLogger)("Endpoints:Context");
+function setupContextEndpoint(server, ctx) {
+  server.middlewares.use(import_core.CONTEXT_API_PATH, async (req, res) => {
+    const reqCtx = new import_node.RequestContext(req.method || "GET", import_core.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") {
+      const pc = ctx.getPageContext();
+      res.writeHead(200);
+      res.end(JSON.stringify(pc));
+      reqCtx.end(200);
+      return;
+    }
+    if (req.method === "DELETE") {
+      ctx.clearSelectedElements();
+      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.toString());
+      req.on("error", () => {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Request error" }));
+      });
+      req.on("end", () => {
+        try {
+          const data = JSON.parse(body);
+          const tabId = data.tabId != null ? String(data.tabId) : "default";
+          const existing = ctx.getPageContext();
+          const newCtx = {
+            url: data.url || "",
+            title: data.title || "",
+            sessionId: data.sessionId,
+            tabId: data.tabId ?? existing.tabId,
+            tabIndex: data.tabIndex ?? existing.tabIndex,
+            selectedElements: data.selectedElements || []
+          };
+          ctx.setPageContext(tabId, newCtx);
+          if (data.active) {
+            ctx.setActiveTabId(tabId);
+          }
+          log.debug("Context updated", {
+            tabId,
+            url: newCtx.url,
+            title: newCtx.title,
+            sessionId: newCtx.sessionId,
+            selectedElementsCount: newCtx.selectedElements?.length || 0
+          });
+          if (newCtx.selectedElements && newCtx.selectedElements.length > 0) {
+            log.debug("Selected elements details", {
+              elements: newCtx.selectedElements.map((el) => ({
+                filePath: el.filePath,
+                line: el.line,
+                text: el.innerText?.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/context.d.ts

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

package/lib/endpoints/index.cjs

@@ -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 __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, {
+  LOGS_API_PATH: () => import_core.LOGS_API_PATH,
+  MCP_API_PATH: () => import_mcp.MCP_API_PATH,
+  VUE_DEVTOOLS_API_PATH: () => import_vue_devtools.VUE_DEVTOOLS_API_PATH,
+  setupMiddlewares: () => setupMiddlewares
+});
+module.exports = __toCommonJS(endpoints_exports);
+var import_widget = require("./widget.cjs");
+var import_context = require("./context.cjs");
+var import_start = require("./start.cjs");
+var import_sse = require("./sse.cjs");
+var import_sessions = require("./sessions.cjs");
+var import_warmup = require("./warmup.cjs");
+var import_logs = require("./logs.cjs");
+var import_mcp = require("./mcp.cjs");
+var import_vue_devtools = require("./vue-devtools.cjs");
+var import_core = require("@aipanel/core");
+__reExport(endpoints_exports, require("./types.cjs"), module.exports);
+function setupMiddlewares(server, ctx, mcp, logFiles) {
+  (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);
+  (0, import_warmup.setupWarmupEndpoint)(server, ctx);
+  (0, import_logs.setupLogsEndpoint)(server);
+  if (mcp) {
+    (0, import_mcp.setupMcpEndpoint)(server, mcp, () => ctx.getPageContext(), logFiles ?? []);
+    (0, import_vue_devtools.setupVueDevtoolsEndpoint)(server, mcp);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOGS_API_PATH,
+  MCP_API_PATH,
+  VUE_DEVTOOLS_API_PATH,
+  setupMiddlewares,
+  ...require("./types.cjs")
+});

package/lib/endpoints/index.d.ts

@@ -0,0 +1,9 @@
+import type { ViteDevServer } from "vite";
+import type { EndpointContext } from "./types";
+import { MCP_API_PATH } from "./mcp";
+import { VUE_DEVTOOLS_API_PATH } from "./vue-devtools";
+import type { McpProxy } from "../core/mcp-proxy";
+import { LOGS_API_PATH, type LogFileConfig } from "@aipanel/core";
+export * from "./types";
+export { LOGS_API_PATH, MCP_API_PATH, VUE_DEVTOOLS_API_PATH };
+export declare function setupMiddlewares(server: ViteDevServer, ctx: EndpointContext, mcp?: McpProxy, logFiles?: LogFileConfig[]): void;

package/lib/endpoints/logs.cjs

@@ -0,0 +1,107 @@
+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 logs_exports = {};
+__export(logs_exports, {
+  setupLogsEndpoint: () => setupLogsEndpoint
+});
+module.exports = __toCommonJS(logs_exports);
+var import_node = require("@aipanel/core/node");
+var import_node2 = require("@aipanel/core/node");
+var import_core = require("@aipanel/core");
+const log = (0, import_node2.createLogger)("Endpoints:Logs");
+function setupLogsEndpoint(server) {
+  server.middlewares.use(import_core.LOGS_API_PATH, async (req, res) => {
+    const reqCtx = new import_node2.RequestContext(req.method || "GET", import_core.LOGS_API_PATH);
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      reqCtx.end(200);
+      return;
+    }
+    const buffer = (0, import_node.getProcessLogBuffer)();
+    if (req.method === "GET") {
+      try {
+        const url = new URL(req.url || "", `http://${req.headers.host || "localhost"}`);
+        const levelParam = url.searchParams.get("level");
+        const limitParam = url.searchParams.get("limit");
+        const sourceParam = url.searchParams.get("source");
+        const sinceParam = url.searchParams.get("since");
+        const options = {};
+        if (levelParam) {
+          const levels = levelParam.split(",").map((l) => l.trim());
+          options.level = levels.length === 1 ? levels[0] : levels;
+        }
+        if (limitParam) {
+          const limit = parseInt(limitParam, 10);
+          if (limit > 0 && limit <= 1e3) {
+            options.limit = limit;
+          }
+        }
+        if (sourceParam) {
+          options.source = sourceParam;
+        }
+        if (sinceParam) {
+          options.since = sinceParam;
+        }
+        const logs = buffer.getLogs(options);
+        log.debug("Logs requested", {
+          params: { level: levelParam, limit: limitParam, source: sourceParam, since: sinceParam },
+          resultCount: logs.length,
+          bufferSize: buffer.size()
+        });
+        res.writeHead(200);
+        res.end(
+          JSON.stringify({
+            logs,
+            meta: {
+              total: buffer.size(),
+              returned: logs.length,
+              filters: options
+            }
+          })
+        );
+        reqCtx.end(200);
+      } catch (e) {
+        log.error("Failed to get logs", { error: e });
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: "Internal server error" }));
+        reqCtx.error(e);
+      }
+      return;
+    }
+    if (req.method === "DELETE") {
+      buffer.clear();
+      log.debug("Log buffer cleared");
+      res.writeHead(200);
+      res.end(JSON.stringify({ success: true, message: "Log buffer cleared" }));
+      reqCtx.end(200);
+      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 = {
+  setupLogsEndpoint
+});

package/lib/endpoints/logs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview 进程日志端点
+ * @description 提供 HTTP API 获取 Vite 进程日志缓冲区内容
+ */
+import type { ViteDevServer } from "vite";
+/**
+ * 设置日志端点
+ */
+export declare function setupLogsEndpoint(server: ViteDevServer): void;