vite-plugin-aipanel 1.2.0-beta.0

package/es/core/provider-loader.mjs

@@ -0,0 +1,30 @@
+const PROVIDER_PACKAGES = {
+  default: "@aipanel/provider-opencode",
+  opencode: "@aipanel/provider-opencode",
+  deepseek: "@aipanel/provider-deepseek"
+};
+async function loadProvider(id, ctx) {
+  const pkg = PROVIDER_PACKAGES[id];
+  if (!pkg) {
+    throw new Error(
+      `\u672A\u77E5\u7684 Web Provider: "${id}"\u3002\u53EF\u7528 Provider: ${Object.keys(PROVIDER_PACKAGES).join(", ") || "(\u65E0)"}`
+    );
+  }
+  let mod;
+  try {
+    mod = await import(pkg);
+  } catch (e) {
+    const error = new Error(
+      `\u52A0\u8F7D Web Provider \u5305 "${pkg}" \u5931\u8D25\uFF08\u8BF7\u786E\u8BA4\u5DF2\u6B63\u786E\u5B89\u88C5\uFF09\uFF1A${e instanceof Error ? e.message : String(e)}`
+    );
+    error.cause = e;
+    throw error;
+  }
+  if (typeof mod.createProvider !== "function") {
+    throw new Error(`Provider \u5305 "${pkg}" \u672A\u5BFC\u51FA createProvider \u5DE5\u5382`);
+  }
+  return mod.createProvider(ctx);
+}
+export {
+  loadProvider
+};

package/es/core/proxy-server.d.ts

@@ -0,0 +1,12 @@
+import http from "http";
+export interface ProxyServerOptions {
+    /** 注入到 HTML 的 Provider 侧桥接脚本（Provider 资产） */
+    bridgeScript?: string;
+    /** 绑定地址，需与端口检查使用的地址族一致，避免 IPv4/IPv6 不匹配 */
+    hostname?: string;
+}
+export interface ProxyServerResult {
+    server: http.Server;
+    actualPort: number;
+}
+export declare function startProxyServer(targetUrl: string, port: number, options?: ProxyServerOptions): Promise<ProxyServerResult>;

package/es/core/proxy-server.mjs

@@ -0,0 +1,148 @@
+import http from "http";
+import { createLogger, BRIDGE_SCRIPT_PATH } from "@aipanel/core";
+const log = createLogger("ProxyServer");
+function startProxyServer(targetUrl, port, options = {}) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(targetUrl);
+    const bridgeScript = options.bridgeScript ?? "";
+    const agent = new http.Agent({
+      keepAlive: true,
+      keepAliveMsecs: 3e4,
+      maxSockets: 50,
+      maxFreeSockets: 10,
+      timeout: 0
+    });
+    const server = http.createServer((req, res) => {
+      if (req.url === BRIDGE_SCRIPT_PATH) {
+        const body = bridgeScript;
+        res.writeHead(200, {
+          "content-type": "application/javascript; charset=utf-8",
+          "cache-control": "no-store",
+          "content-length": Buffer.byteLength(body)
+        });
+        res.end(body);
+        return;
+      }
+      const requestOptions = {
+        agent,
+        hostname: target.hostname,
+        port: target.port,
+        path: req.url,
+        method: req.method,
+        headers: {
+          ...req.headers,
+          host: target.host,
+          // 上游（如 dsh 的 trust fence）校验 Origin 必须匹配自身 origin；
+          // 页面经代理访问时浏览器发的 Origin 是代理端口，须改写为目标 origin 否则 403
+          origin: `http://${target.host}`,
+          "accept-encoding": "identity"
+        },
+        timeout: 0
+      };
+      const proxyReq = http.request(requestOptions, (proxyRes) => {
+        const rawContentType = proxyRes.headers["content-type"];
+        const contentType = Array.isArray(rawContentType) ? rawContentType[0] ?? "" : rawContentType ?? "";
+        if (contentType.includes("text/html")) {
+          const chunks = [];
+          proxyRes.on("data", (chunk) => {
+            chunks.push(chunk);
+          });
+          proxyRes.on("end", () => {
+            let body = Buffer.concat(chunks).toString("utf-8");
+            if (body.match(/<\/head>/i)) {
+              body = body.replace(
+                /<\/head>/i,
+                `<script src="${BRIDGE_SCRIPT_PATH}"></script></head>`
+              );
+            } else if (body.match(/<\/body>/i)) {
+              body = body.replace(
+                /<\/body>/i,
+                `<script src="${BRIDGE_SCRIPT_PATH}"></script></body>`
+              );
+            } else {
+              body += `<script src="${BRIDGE_SCRIPT_PATH}"></script>`;
+            }
+            const headers = {};
+            for (const [key, value] of Object.entries(proxyRes.headers)) {
+              if (value !== void 0 && key !== "content-encoding" && key !== "transfer-encoding" && key !== "content-length") {
+                headers[key] = value;
+              }
+            }
+            headers["content-length"] = Buffer.byteLength(body);
+            res.writeHead(proxyRes.statusCode || 200, headers);
+            res.end(body);
+          });
+        } else {
+          res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+          proxyRes.pipe(res);
+        }
+      });
+      proxyReq.on("error", (err) => {
+        log.error("Proxy error", { error: err.message, url: req.url });
+        res.writeHead(502);
+        res.end("Proxy error");
+      });
+      proxyReq.on("socket", (socket) => {
+        socket.setTimeout(0);
+      });
+      req.on("socket", (socket) => {
+        socket.setTimeout(0);
+      });
+      req.pipe(proxyReq);
+    });
+    server.on("error", (err) => {
+      reject(err);
+    });
+    server.on("upgrade", (req, clientSocket, head) => {
+      const upgradeOptions = {
+        hostname: target.hostname,
+        port: target.port,
+        path: req.url,
+        method: req.method,
+        // upgrade 不复用 keep-alive 连接池
+        agent: false,
+        headers: {
+          ...req.headers,
+          host: target.host,
+          // 与 HTTP 分支一致：改写 Origin 为目标 origin，通过 dsh 的 trust fence
+          origin: `http://${target.host}`
+        }
+      };
+      const proxyReq = http.request(upgradeOptions);
+      proxyReq.on("upgrade", (proxyRes, proxySocket, proxyHead) => {
+        proxySocket.removeAllListeners("data");
+        proxySocket.setTimeout(0);
+        clientSocket.setTimeout(0);
+        const headBuf = [
+          `HTTP/1.1 ${proxyRes.statusCode} ${proxyRes.statusMessage}`,
+          ...Object.entries(proxyRes.headers).map(([k, v]) => `${k}: ${v}`),
+          "",
+          ""
+        ].join("\r\n");
+        clientSocket.write(headBuf);
+        if (head?.length) proxySocket.write(head);
+        if (proxyHead?.length) clientSocket.write(proxyHead);
+        proxySocket.pipe(clientSocket);
+        clientSocket.pipe(proxySocket);
+        proxySocket.on("close", () => clientSocket.destroy());
+        clientSocket.on("close", () => proxySocket.destroy());
+      });
+      proxyReq.on("error", (err) => {
+        log.warn("Proxy websocket upgrade failed", { error: err.message, url: req.url });
+        clientSocket.destroy();
+      });
+      proxyReq.end();
+    });
+    server.timeout = 0;
+    server.keepAliveTimeout = 0;
+    server.listen(port, options.hostname || void 0, () => {
+      const address = server.address();
+      const actualPort = typeof address === "object" && address ? address.port : port;
+      log.debug(`Proxy server started on port ${actualPort} -> ${targetUrl}`);
+      resolve({ server, actualPort });
+    });
+  });
+}
+export {
+  startProxyServer
+};

package/es/core/service.d.ts

@@ -0,0 +1,39 @@
+import type { ResultPromise } from "execa";
+import type http from "http";
+import type { PluginOptions, ServiceStartupTask, WebProvider } from "@aipanel/core";
+import { ChromeMcpWarmupErrorType } from "@aipanel/core";
+import type { McpProxy } from "./mcp-proxy";
+export declare class AIPanelService {
+    private config;
+    private sseClients;
+    private onPortAllocated;
+    private onProxyPortAllocated;
+    webProcess: ResultPromise | null;
+    actualWebPort: number;
+    actualProxyPort: number;
+    isStarted: boolean;
+    private startPromise;
+    private proxyServer;
+    chromeMcpWarmupFailed: boolean;
+    chromeMcpWarmupErrorType: ChromeMcpWarmupErrorType | null;
+    chromeMcpWarmupErrorMessage: string | null;
+    currentTask: {
+        task: ServiceStartupTask;
+        data?: Record<string, unknown>;
+    } | null;
+    workspaceRoot: string | null;
+    private mcp;
+    private provider;
+    private unsubscribeEvents;
+    constructor(config: Required<PluginOptions>, sseClients: Set<http.ServerResponse>, onPortAllocated: (port: number) => void, onProxyPortAllocated: (port: number) => void);
+    /** 设置 Provider（由编排层动态加载后调用） */
+    setProvider(provider: WebProvider): void;
+    private sendTaskUpdate;
+    start(vitePort: number, corsOrigins: string[], contextApiUrl: string, logsApiUrl: string, viteOrigin: string, mcp: McpProxy, vueDevtoolsApiUrl?: string): Promise<void>;
+    retryWarmupChromeMcp(): Promise<{
+        success: boolean;
+        errorType?: string;
+        errorMessage?: string;
+    }>;
+    stop(): Promise<void>;
+}

package/es/core/service.mjs

@@ -0,0 +1,267 @@
+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);
+import { DEFAULT_PROXY_PORT, SERVER_START_TIMEOUT, ChromeMcpWarmupErrorType } from "@aipanel/core";
+import { createLogger, findAvailablePort } from "@aipanel/core/node";
+import { findGitRoot, waitForServer } from "../utils/system.mjs";
+import { startProxyServer } from "./proxy-server.mjs";
+const log = createLogger("Service");
+class AIPanelService {
+  constructor(config, sseClients, onPortAllocated, onProxyPortAllocated) {
+    __publicField(this, "config", config);
+    __publicField(this, "sseClients", sseClients);
+    __publicField(this, "onPortAllocated", onPortAllocated);
+    __publicField(this, "onProxyPortAllocated", onProxyPortAllocated);
+    __publicField(this, "webProcess", null);
+    __publicField(this, "actualWebPort");
+    __publicField(this, "actualProxyPort");
+    __publicField(this, "isStarted", false);
+    __publicField(this, "startPromise", null);
+    __publicField(this, "proxyServer", null);
+    __publicField(this, "chromeMcpWarmupFailed", false);
+    __publicField(this, "chromeMcpWarmupErrorType", null);
+    __publicField(this, "chromeMcpWarmupErrorMessage", null);
+    __publicField(this, "currentTask", null);
+    __publicField(this, "workspaceRoot", null);
+    __publicField(this, "mcp", null);
+    __publicField(this, "provider", null);
+    __publicField(this, "unsubscribeEvents", null);
+    this.actualWebPort = config.webPort;
+    this.actualProxyPort = config.proxyPort ?? DEFAULT_PROXY_PORT;
+  }
+  /** 设置 Provider（由编排层动态加载后调用） */
+  setProvider(provider) {
+    this.provider = provider;
+  }
+  sendTaskUpdate(task, data) {
+    this.currentTask = { task, ...data };
+    this.sseClients.forEach((client) => {
+      try {
+        client.write(`data: ${JSON.stringify({ type: "TASK_UPDATE", task, ...data })}
+
+`);
+      } catch (e) {
+        log.debug("Failed to send TASK_UPDATE event", { error: e });
+      }
+    });
+  }
+  async start(vitePort, corsOrigins, contextApiUrl, logsApiUrl, viteOrigin, mcp, vueDevtoolsApiUrl) {
+    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.mcp = mcp;
+    const provider = this.provider;
+    if (!provider) {
+      throw new Error("Provider \u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 setProvider");
+    }
+    this.startPromise = (async () => {
+      const timer = log.timer("startServices", {
+        corsOrigins,
+        contextApiUrl,
+        logsApiUrl,
+        viteOrigin
+      });
+      log.info("Starting Web UI services...");
+      const orphanCount = await provider.killOrphans?.() ?? 0;
+      if (orphanCount > 0) {
+        log.debug(`Killed ${orphanCount} orphan Web UI process(es)`);
+      }
+      this.sendTaskUpdate("checking_provider");
+      const env = await provider.checkEnvironment();
+      if (!env.ok) {
+        log.error(env.message ?? "Provider environment check failed");
+        this.sendTaskUpdate("provider_not_installed");
+        this.startPromise = null;
+        timer.end("\u274C Provider environment check failed");
+        return;
+      }
+      const providerVersion = env.version;
+      timer.checkpoint("Provider environment verified");
+      this.sendTaskUpdate("allocating_port");
+      this.actualWebPort = await 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");
+      this.workspaceRoot = findGitRoot(process.cwd());
+      log.debug(`Using workspace root: ${this.workspaceRoot}`);
+      this.sendTaskUpdate("preparing_runtime");
+      this.sendTaskUpdate("starting_web");
+      let webUrl;
+      try {
+        const startResult = await provider.start({
+          port: this.actualWebPort,
+          hostname: this.config.hostname,
+          cwd: this.workspaceRoot,
+          corsOrigins,
+          vitePort,
+          contextApiUrl,
+          logsApiUrl,
+          verbose: this.config.verbose,
+          vueDevtoolsApiUrl
+        });
+        this.webProcess = startResult.processHandle ?? null;
+        timer.checkpoint("Web process started");
+        webUrl = startResult.url;
+        log.debug(`Waiting for Web UI to become ready at ${webUrl}...`);
+        this.sendTaskUpdate("waiting_web_ready");
+        await waitForServer(webUrl, SERVER_START_TIMEOUT, this.webProcess ?? void 0);
+        if (this.webProcess?.exitCode !== null && this.webProcess?.exitCode !== void 0) {
+          throw new Error(`Web process exited with code ${this.webProcess.exitCode}`);
+        }
+        log.info(
+          `Web UI started at ${webUrl}${providerVersion ? ` (${provider.displayName} ${providerVersion})` : ""}`
+        );
+      } catch (e) {
+        log.error("Web UI failed to start", { error: e });
+        this.sendTaskUpdate("web_start_timeout");
+        await provider.stop();
+        this.webProcess = null;
+        this.startPromise = null;
+        timer.end("\u274C Web start timeout");
+        return;
+      }
+      this.sendTaskUpdate("starting_proxy");
+      let proxyStartPort = this.config.proxyPort ?? DEFAULT_PROXY_PORT;
+      if (proxyStartPort === this.actualWebPort) {
+        proxyStartPort = this.actualWebPort + 1;
+        log.debug(`Proxy start port conflicts with web port, using ${proxyStartPort} instead`);
+      }
+      this.actualProxyPort = await findAvailablePort(proxyStartPort, this.config.hostname);
+      this.onProxyPortAllocated(this.actualProxyPort);
+      if (this.actualProxyPort !== (this.config.proxyPort ?? DEFAULT_PROXY_PORT)) {
+        log.info(
+          `Proxy port ${this.config.proxyPort ?? DEFAULT_PROXY_PORT} is in use, using ${this.actualProxyPort} instead`
+        );
+      } else {
+        log.debug(`Using proxy port ${this.actualProxyPort}`);
+      }
+      try {
+        const result = await startProxyServer(webUrl, this.actualProxyPort, {
+          bridgeScript: provider.bridgeScript,
+          hostname: this.config.hostname
+        });
+        this.proxyServer = result.server;
+        if (result.actualPort !== this.actualProxyPort) {
+          log.info(
+            `Proxy port ${this.actualProxyPort} was taken, using ${result.actualPort} instead`
+          );
+          this.actualProxyPort = result.actualPort;
+          this.onProxyPortAllocated(this.actualProxyPort);
+        }
+      } catch (err) {
+        const nodeErr = err;
+        if (nodeErr.code === "EADDRINUSE") {
+          log.debug(`Proxy port ${this.actualProxyPort} became unavailable, trying next port...`);
+          const nextPort = await findAvailablePort(this.actualProxyPort + 1, this.config.hostname);
+          const result = await startProxyServer(webUrl, nextPort, {
+            bridgeScript: provider.bridgeScript,
+            hostname: this.config.hostname
+          });
+          this.proxyServer = result.server;
+          this.actualProxyPort = result.actualPort;
+          this.onProxyPortAllocated(this.actualProxyPort);
+          log.debug(`Proxy server started on fallback port ${this.actualProxyPort}`);
+        } else {
+          log.error("Proxy server failed to start", { error: nodeErr });
+          this.sendTaskUpdate("proxy_start_failed", {
+            errorMessage: nodeErr.message
+          });
+          await provider.stop();
+          this.webProcess = null;
+          this.startPromise = null;
+          return;
+        }
+      }
+      timer.checkpoint("Proxy server started");
+      this.sendTaskUpdate("warming_up_chrome");
+      let warmupFailed = false;
+      try {
+        const result = await mcp.verify();
+        if (!result.ok) throw new Error(result.error ?? "Chrome MCP not available");
+        timer.checkpoint("Chrome MCP warmup complete");
+      } catch (e) {
+        log.warn("Chrome MCP warmup failed", { error: e });
+        this.chromeMcpWarmupFailed = true;
+        warmupFailed = true;
+        this.chromeMcpWarmupErrorType = ChromeMcpWarmupErrorType.UNKNOWN;
+        this.chromeMcpWarmupErrorMessage = e instanceof Error ? e.message : String(e);
+      }
+      this.sendTaskUpdate("creating_session");
+      this.isStarted = true;
+      this.unsubscribeEvents?.();
+      this.unsubscribeEvents = provider.subscribeEvents((event) => {
+        this.sseClients.forEach((client) => {
+          try {
+            client.write(`data: ${JSON.stringify({ type: "SESSION_EVENT", event })}
+
+`);
+          } catch (e) {
+            log.debug("Failed to send SESSION_EVENT", { error: e });
+          }
+        });
+      });
+      if (warmupFailed) {
+        this.sendTaskUpdate("chrome_mcp_failed", {
+          errorType: this.chromeMcpWarmupErrorType,
+          errorMessage: this.chromeMcpWarmupErrorMessage
+        });
+      } else {
+        this.sendTaskUpdate("ready");
+      }
+      timer.end("\u2713 Services started successfully");
+    })();
+    return this.startPromise;
+  }
+  async retryWarmupChromeMcp() {
+    if (!this.mcp) {
+      return { success: false, errorType: "UNKNOWN", errorMessage: "MCP not initialized" };
+    }
+    try {
+      const result = await this.mcp.verify();
+      if (result.ok) {
+        this.chromeMcpWarmupFailed = false;
+        this.sendTaskUpdate("ready");
+        return { success: true };
+      }
+      return {
+        success: false,
+        errorType: "CHROME_NOT_CONNECTED",
+        errorMessage: result.error ?? "Chrome MCP not available"
+      };
+    } catch (e) {
+      return {
+        success: false,
+        errorType: "UNKNOWN",
+        errorMessage: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  async stop() {
+    const timer = log.timer("stopServices");
+    log.info("Stopping Web UI services...");
+    this.unsubscribeEvents?.();
+    this.unsubscribeEvents = null;
+    if (this.proxyServer) {
+      log.debug("Closing proxy server");
+      this.proxyServer.close();
+      this.proxyServer = null;
+    }
+    await this.provider?.stop();
+    this.webProcess = null;
+    this.isStarted = false;
+    this.startPromise = null;
+    timer.end("\u2713 Services stopped");
+  }
+}
+export {
+  AIPanelService
+};

package/es/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/es/endpoints/context.mjs

@@ -0,0 +1,106 @@
+import { CONTEXT_API_PATH } from "@aipanel/core";
+import { RequestContext, createLogger } from "@aipanel/core/node";
+const log = createLogger("Endpoints:Context");
+function setupContextEndpoint(server, ctx) {
+  server.middlewares.use(CONTEXT_API_PATH, async (req, res) => {
+    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") {
+      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);
+  });
+}
+export {
+  setupContextEndpoint
+};

package/es/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/es/endpoints/index.mjs

@@ -0,0 +1,30 @@
+import { setupWidgetEndpoints } from "./widget.mjs";
+import { setupContextEndpoint } from "./context.mjs";
+import { setupStartEndpoint } from "./start.mjs";
+import { setupSseEndpoint } from "./sse.mjs";
+import { setupSessionsEndpoint } from "./sessions.mjs";
+import { setupWarmupEndpoint } from "./warmup.mjs";
+import { setupLogsEndpoint } from "./logs.mjs";
+import { setupMcpEndpoint, MCP_API_PATH } from "./mcp.mjs";
+import { setupVueDevtoolsEndpoint, VUE_DEVTOOLS_API_PATH } from "./vue-devtools.mjs";
+import { LOGS_API_PATH } from "@aipanel/core";
+export * from "./types.mjs";
+function setupMiddlewares(server, ctx, mcp, logFiles) {
+  setupWidgetEndpoints(server, ctx);
+  setupContextEndpoint(server, ctx);
+  setupStartEndpoint(server, ctx);
+  setupSseEndpoint(server, ctx);
+  setupSessionsEndpoint(server, ctx);
+  setupWarmupEndpoint(server, ctx);
+  setupLogsEndpoint(server);
+  if (mcp) {
+    setupMcpEndpoint(server, mcp, () => ctx.getPageContext(), logFiles ?? []);
+    setupVueDevtoolsEndpoint(server, mcp);
+  }
+}
+export {
+  LOGS_API_PATH,
+  MCP_API_PATH,
+  VUE_DEVTOOLS_API_PATH,
+  setupMiddlewares
+};

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