vite-plugin-aipanel 1.2.0-beta.0

package/lib/core/mcp-tools.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 自定义 DevTools 工具定义
+ * 所有工具（除 chrome-devtools_list_pages）必须传入 pageId 参数，
+ * 代理层校验 pageId 是否为项目页面后方可调用 chrome-devtools-mcp。
+ */
+export interface CustomTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export declare const CUSTOM_TOOLS: CustomTool[];

package/lib/core/provider-loader.cjs

@@ -0,0 +1,53 @@
+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 provider_loader_exports = {};
+__export(provider_loader_exports, {
+  loadProvider: () => loadProvider
+});
+module.exports = __toCommonJS(provider_loader_exports);
+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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadProvider
+});

package/lib/core/provider-loader.d.ts

@@ -0,0 +1,19 @@
+import type { ProviderInitContext, WebProvider } from "@aipanel/core";
+/**
+ * id → Provider npm 包名映射（登记制）
+ * "default" 是默认别名（未配置 provider 时的兜底），其他键为 Provider 真实 id。
+ * 这里只有包名字符串，无静态依赖；加载与初始化完全由 Provider 包自身完成。
+ */
+declare const PROVIDER_PACKAGES: {
+    readonly default: "@aipanel/provider-opencode";
+    readonly opencode: "@aipanel/provider-opencode";
+    readonly deepseek: "@aipanel/provider-deepseek";
+};
+/** 已登记的 Provider id 联合类型（与运行时映射保持单一事实来源） */
+export type ProviderId = keyof typeof PROVIDER_PACKAGES;
+/**
+ * 按 id 动态加载 Provider 包并初始化
+ * 约定：Provider 包必须导出 createProvider(ctx): WebProvider 工厂
+ */
+export declare function loadProvider(id: string, ctx: ProviderInitContext): Promise<WebProvider>;
+export {};

package/lib/core/proxy-server.cjs

@@ -0,0 +1,181 @@
+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 proxy_server_exports = {};
+__export(proxy_server_exports, {
+  startProxyServer: () => startProxyServer
+});
+module.exports = __toCommonJS(proxy_server_exports);
+var import_http = __toESM(require("http"));
+var import_core = require("@aipanel/core");
+const log = (0, import_core.createLogger)("ProxyServer");
+function startProxyServer(targetUrl, port, options = {}) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(targetUrl);
+    const bridgeScript = options.bridgeScript ?? "";
+    const agent = new import_http.default.Agent({
+      keepAlive: true,
+      keepAliveMsecs: 3e4,
+      maxSockets: 50,
+      maxFreeSockets: 10,
+      timeout: 0
+    });
+    const server = import_http.default.createServer((req, res) => {
+      if (req.url === import_core.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 = import_http.default.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="${import_core.BRIDGE_SCRIPT_PATH}"></script></head>`
+              );
+            } else if (body.match(/<\/body>/i)) {
+              body = body.replace(
+                /<\/body>/i,
+                `<script src="${import_core.BRIDGE_SCRIPT_PATH}"></script></body>`
+              );
+            } else {
+              body += `<script src="${import_core.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 = import_http.default.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 });
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startProxyServer
+});

package/lib/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/lib/core/service.cjs

@@ -0,0 +1,289 @@
+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 service_exports = {};
+__export(service_exports, {
+  AIPanelService: () => AIPanelService
+});
+module.exports = __toCommonJS(service_exports);
+var import_core = require("@aipanel/core");
+var import_node = require("@aipanel/core/node");
+var import_system = require("../utils/system.cjs");
+var import_proxy_server = require("./proxy-server.cjs");
+const log = (0, import_node.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 ?? import_core.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 (0, import_node.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 = (0, import_system.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 (0, import_system.waitForServer)(webUrl, import_core.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 ?? import_core.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 (0, import_node.findAvailablePort)(proxyStartPort, this.config.hostname);
+      this.onProxyPortAllocated(this.actualProxyPort);
+      if (this.actualProxyPort !== (this.config.proxyPort ?? import_core.DEFAULT_PROXY_PORT)) {
+        log.info(
+          `Proxy port ${this.config.proxyPort ?? import_core.DEFAULT_PROXY_PORT} is in use, using ${this.actualProxyPort} instead`
+        );
+      } else {
+        log.debug(`Using proxy port ${this.actualProxyPort}`);
+      }
+      try {
+        const result = await (0, import_proxy_server.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 (0, import_node.findAvailablePort)(this.actualProxyPort + 1, this.config.hostname);
+          const result = await (0, import_proxy_server.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 = import_core.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");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIPanelService
+});

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