@aipanel/core 1.2.0-beta.0

package/es/logger.mjs

@@ -0,0 +1,127 @@
+import { LOG_PREFIX } from "./constants.mjs";
+import {
+  LogLevel,
+  getConfig,
+  getTimestamp,
+  formatContext,
+  formatValue
+} from "./logger-core.mjs";
+const LEVEL_NAMES = {
+  [LogLevel.DEBUG]: "DEBUG",
+  [LogLevel.INFO]: "INFO ",
+  [LogLevel.WARN]: "WARN ",
+  [LogLevel.ERROR]: "ERROR",
+  [LogLevel.NONE]: "NONE "
+};
+const C = {
+  dim: "color: #888",
+  bright: "font-weight: bold",
+  red: "color: #cd0000; font-weight: bold",
+  green: "color: #00cd00",
+  yellow: "color: #cdcd00",
+  blue: "color: #0000cd",
+  magenta: "color: #cd00cd",
+  cyan: "color: #00cdcd",
+  reset: ""
+};
+const LEVEL_COLORS = {
+  [LogLevel.DEBUG]: C.cyan,
+  [LogLevel.INFO]: C.green,
+  [LogLevel.WARN]: C.yellow,
+  [LogLevel.ERROR]: C.red,
+  [LogLevel.NONE]: C.reset
+};
+function log(level, message, context, ...args) {
+  if (level < getConfig().level) return;
+  const segments = [];
+  const styles = [];
+  if (getConfig().showTimestamp) {
+    segments.push("%c%s");
+    styles.push(C.dim, getTimestamp());
+  }
+  segments.push(`%c${LEVEL_NAMES[level]}`);
+  styles.push(LEVEL_COLORS[level]);
+  segments.push(`%c${LOG_PREFIX}`);
+  styles.push(C.bright);
+  const ctxStr = formatContext(context);
+  if (ctxStr) {
+    segments.push(`%c${ctxStr}`);
+    styles.push(C.magenta);
+  }
+  const formattedArgs = args.length > 0 ? ` ${args.map((a) => formatValue(a)).join(" ")}` : "";
+  segments.push(`%c${message}${formattedArgs}`);
+  styles.push(C.reset);
+  const output = segments.join(" ");
+  if (context?.error) {
+    const err = context.error;
+    if (err instanceof Error) {
+      if (level >= LogLevel.ERROR && getConfig().showTrace && err.stack) {
+        console.error(output, ...styles, `
+${err.stack}`);
+      } else {
+        console.error(output, ...styles, `
+%cError: ${err.message}`, C.red);
+      }
+    } else {
+      console.error(output, ...styles, `
+%cError: ${formatValue(err)}`, C.red);
+    }
+    return;
+  }
+  if (level >= LogLevel.ERROR) {
+    console.error(output, ...styles);
+  } else if (level === LogLevel.WARN) {
+    console.warn(output, ...styles);
+  } else if (level === LogLevel.DEBUG) {
+    console.debug(output, ...styles);
+  } else {
+    console.log(output, ...styles);
+  }
+}
+const logger = {
+  debug(message, context, ...args) {
+    log(LogLevel.DEBUG, message, context, ...args);
+  },
+  info(message, context, ...args) {
+    log(LogLevel.INFO, message, context, ...args);
+  },
+  warn(message, context, ...args) {
+    log(LogLevel.WARN, message, context, ...args);
+  },
+  error(message, context, ...args) {
+    log(LogLevel.ERROR, message, context, ...args);
+  },
+  group(label, context) {
+    if (!getConfig().verbose) return;
+    console.group(
+      `%c${LOG_PREFIX}%c ${label}`,
+      C.bright,
+      context?.module ? `%c[${context.module}]%c ` : C.reset,
+      ...context?.module ? [C.magenta, C.reset] : []
+    );
+  },
+  groupEnd() {
+    if (!getConfig().verbose) return;
+    console.groupEnd();
+  }
+};
+function createLogger(module) {
+  return {
+    debug(message, context, ...args) {
+      logger.debug(message, { ...context, module }, ...args);
+    },
+    info(message, context, ...args) {
+      logger.info(message, { ...context, module }, ...args);
+    },
+    warn(message, context, ...args) {
+      logger.warn(message, { ...context, module }, ...args);
+    },
+    error(message, context, ...args) {
+      logger.error(message, { ...context, module }, ...args);
+    }
+  };
+}
+export {
+  createLogger,
+  logger
+};

package/es/node-logger.d.ts

@@ -0,0 +1,38 @@
+import { type LogContext } from "./logger-core";
+export declare const nodeLogger: {
+    debug(message: string, context?: LogContext, ...args: unknown[]): void;
+    info(message: string, context?: LogContext, ...args: unknown[]): void;
+    warn(message: string, context?: LogContext, ...args: unknown[]): void;
+    error(message: string, context?: LogContext, ...args: unknown[]): void;
+    group(label: string, context?: LogContext): void;
+    groupEnd(): void;
+};
+export declare function createNodeLogger(module: string): {
+    debug(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    info(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    warn(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    error(message: string, context?: Omit<LogContext, "module">, ...args: unknown[]): void;
+    timer(operation: string, context?: Omit<LogContext, "module">): PerformanceTimer;
+};
+export declare class PerformanceTimer {
+    private startTime;
+    private context;
+    private operation;
+    constructor(operation: string, context?: LogContext);
+    end(message?: string): number;
+    checkpoint(label: string): number;
+}
+export declare class RequestContext {
+    traceId: string;
+    method: string;
+    path: string;
+    startTime: number;
+    private checkpoints;
+    constructor(method: string, path: string);
+    checkpoint(label: string): void;
+    end(statusCode: number): void;
+    error(error: Error | unknown): void;
+}
+export declare function logMethod(target: unknown, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+export { nodeLogger as logger };
+export { createNodeLogger as createLogger };

package/es/node-logger.mjs

@@ -0,0 +1,230 @@
+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 { LOG_PREFIX } from "./constants.mjs";
+import {
+  LogLevel,
+  getConfig,
+  formatContext,
+  formatValue,
+  generateTraceId as _generateTraceId
+} from "./logger-core.mjs";
+const COLORS = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bright: "\x1B[1m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+const LEVEL_COLORS = {
+  [LogLevel.DEBUG]: COLORS.cyan,
+  [LogLevel.INFO]: COLORS.green,
+  [LogLevel.WARN]: COLORS.yellow,
+  [LogLevel.ERROR]: COLORS.red,
+  [LogLevel.NONE]: COLORS.reset
+};
+const LEVEL_NAMES = {
+  [LogLevel.DEBUG]: "DEBUG",
+  [LogLevel.INFO]: "INFO",
+  [LogLevel.WARN]: "WARN",
+  [LogLevel.ERROR]: "ERROR",
+  [LogLevel.NONE]: "NONE"
+};
+function getTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `${hours}:${minutes}:${seconds}.${ms}`;
+}
+function getCallerInfo(depth = 3) {
+  const stack = new Error().stack;
+  if (!stack) return "";
+  const lines = stack.split("\n");
+  const targetLine = lines[depth];
+  if (!targetLine) return "";
+  const match = targetLine.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+  if (!match) return "";
+  const [, funcName, filePath, line] = match;
+  const fileName = filePath.split("/").pop() || filePath;
+  const func = funcName || "<anonymous>";
+  return `${fileName}:${line} ${func}`;
+}
+function log(level, message, context, ...args) {
+  if (level < getConfig().level) return;
+  const parts = [];
+  parts.push(`${COLORS.dim}[${process.pid}]${COLORS.reset}`);
+  if (getConfig().showTimestamp) {
+    parts.push(`${COLORS.dim}${getTimestamp()}${COLORS.reset}`);
+  }
+  const levelColor = LEVEL_COLORS[level];
+  const levelName = LEVEL_NAMES[level].padEnd(5);
+  parts.push(`${levelColor}${levelName}${COLORS.reset}`);
+  parts.push(`${COLORS.bright}${LOG_PREFIX}${COLORS.reset}`);
+  const contextStr = formatContext(context);
+  if (contextStr) {
+    parts.push(`${COLORS.magenta}${contextStr}${COLORS.reset}`);
+  }
+  parts.push(message);
+  if (getConfig().showCaller && level >= LogLevel.WARN) {
+    const caller = getCallerInfo(4);
+    if (caller) {
+      parts.push(`${COLORS.dim}(${caller})${COLORS.reset}`);
+    }
+  }
+  const formattedArgs = args.map((a) => formatValue(a)).join(" ");
+  if (formattedArgs) {
+    parts.push(formattedArgs);
+  }
+  if (context?.error) {
+    const err = context.error;
+    if (err instanceof Error) {
+      parts.push(`${COLORS.red}Error: ${err.message}${COLORS.reset}`);
+      if (level >= LogLevel.ERROR && getConfig().showTrace && err.stack) {
+        console.error(`${COLORS.dim}${err.stack}${COLORS.reset}`);
+      }
+    } else {
+      parts.push(`${COLORS.red}Error: ${formatValue(err)}${COLORS.reset}`);
+    }
+  }
+  const output = parts.join(" ");
+  if (level >= LogLevel.ERROR) {
+    console.error(output);
+  } else if (level === LogLevel.WARN) {
+    console.warn(output);
+  } else {
+    console.log(output);
+  }
+}
+const nodeLogger = {
+  debug(message, context, ...args) {
+    log(LogLevel.DEBUG, message, context, ...args);
+  },
+  info(message, context, ...args) {
+    log(LogLevel.INFO, message, context, ...args);
+  },
+  warn(message, context, ...args) {
+    log(LogLevel.WARN, message, context, ...args);
+  },
+  error(message, context, ...args) {
+    log(LogLevel.ERROR, message, context, ...args);
+  },
+  group(label, context) {
+    if (!getConfig().verbose) return;
+    const contextStr = formatContext(context);
+    console.log(
+      `${COLORS.dim}[${process.pid}]${COLORS.reset} ${COLORS.bright}${LOG_PREFIX}${COLORS.reset} ${COLORS.blue}\u25BC${COLORS.reset} ${label}${contextStr ? ` ${contextStr}` : ""}`
+    );
+  },
+  groupEnd() {
+    if (!getConfig().verbose) return;
+  }
+};
+function createNodeLogger(module) {
+  return {
+    debug(message, context, ...args) {
+      nodeLogger.debug(message, { ...context, module }, ...args);
+    },
+    info(message, context, ...args) {
+      nodeLogger.info(message, { ...context, module }, ...args);
+    },
+    warn(message, context, ...args) {
+      nodeLogger.warn(message, { ...context, module }, ...args);
+    },
+    error(message, context, ...args) {
+      nodeLogger.error(message, { ...context, module }, ...args);
+    },
+    timer(operation, context) {
+      return new PerformanceTimer(operation, { ...context, module });
+    }
+  };
+}
+class PerformanceTimer {
+  constructor(operation, context) {
+    __publicField(this, "startTime");
+    __publicField(this, "context");
+    __publicField(this, "operation");
+    this.operation = operation;
+    this.context = context || {};
+    this.startTime = performance.now();
+    nodeLogger.debug(`\u23F1\uFE0F  Starting: ${operation}`, this.context);
+  }
+  end(message) {
+    const duration = Math.round(performance.now() - this.startTime);
+    const msg = message || `\u2713 Completed: ${this.operation}`;
+    nodeLogger.debug(msg, { ...this.context, duration });
+    return duration;
+  }
+  checkpoint(label) {
+    const elapsed = Math.round(performance.now() - this.startTime);
+    nodeLogger.debug(`  \u21B3 ${label}`, { ...this.context, duration: elapsed });
+    return elapsed;
+  }
+}
+class RequestContext {
+  constructor(method, path) {
+    __publicField(this, "traceId");
+    __publicField(this, "method");
+    __publicField(this, "path");
+    __publicField(this, "startTime");
+    __publicField(this, "checkpoints", []);
+    this.traceId = _generateTraceId();
+    this.method = method;
+    this.path = path;
+    this.startTime = performance.now();
+    nodeLogger.debug(`\u2192 ${method} ${path}`, { traceId: this.traceId, module: "HTTP" });
+  }
+  checkpoint(label) {
+    const elapsed = Math.round(performance.now() - this.startTime);
+    this.checkpoints.push({ time: elapsed, label });
+    nodeLogger.debug(`  \u2192 ${label}`, { traceId: this.traceId, duration: elapsed });
+  }
+  end(statusCode) {
+    const duration = Math.round(performance.now() - this.startTime);
+    const statusColor = statusCode < 400 ? COLORS.green : COLORS.red;
+    nodeLogger.debug(`\u2190 ${this.method} ${this.path} ${statusColor}${statusCode}${COLORS.reset}`, {
+      traceId: this.traceId,
+      duration,
+      checkpoints: this.checkpoints.length
+    });
+  }
+  error(error) {
+    const duration = Math.round(performance.now() - this.startTime);
+    nodeLogger.error(`\u2717 ${this.method} ${this.path}`, {
+      traceId: this.traceId,
+      duration,
+      error
+    });
+  }
+}
+function logMethod(target, propertyKey, descriptor) {
+  const originalMethod = descriptor.value;
+  const className = target.constructor.name;
+  descriptor.value = async function(...args) {
+    const timer = new PerformanceTimer(`${className}.${propertyKey}`);
+    try {
+      const result = await originalMethod.apply(this, args);
+      timer.end();
+      return result;
+    } catch (error) {
+      timer.end("\u274C Failed");
+      throw error;
+    }
+  };
+  return descriptor;
+}
+export {
+  PerformanceTimer,
+  RequestContext,
+  createNodeLogger as createLogger,
+  createNodeLogger,
+  logMethod,
+  nodeLogger as logger,
+  nodeLogger
+};

package/es/node-utils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Node.js 专用工具函数（仅服务端可用）
+ */
+/**
+ * 创建一个锚定到指定目录（默认 process.cwd()）的 require。
+ * 跨 ESM/CJS 安全，避免依赖 __dirname / import.meta.url（CJS 打包时会与 Node 内置变量冲突或被置空）。
+ */
+export declare function createPackageRequire(baseDir?: string): NodeJS.Require;
+/**
+ * 解析 npm 包根目录（跨 ESM/CJS 安全）。
+ * @param packageName - 包名，例如 "vite-plugin-aipanel"
+ * @param baseDir - 解析基准目录，默认当前工作目录
+ */
+export declare function resolvePackageDir(packageName: string, baseDir?: string): string;
+/**
+ * 检查 Chrome DevTools 是否可用
+ * @param timeout - 超时时间（毫秒），默认 2000ms
+ * @returns Chrome DevTools 是否可用
+ */
+export declare function checkChromeDevToolsAvailable(port?: number, timeout?: number): Promise<boolean>;
+/**
+ * 检查指定端口是否可用
+ */
+export declare function isPortAvailable(port: number, hostname?: string): Promise<boolean>;
+/**
+ * 从 startPort 开始寻找可用端口
+ */
+export declare function findAvailablePort(startPort: number, hostname?: string, maxTries?: number): Promise<number>;

package/es/node-utils.mjs

@@ -0,0 +1,56 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { CHROME_DEVTOOLS_PORT, CHROME_DEVTOOLS_CHECK_TIMEOUT } from "./constants.mjs";
+function createPackageRequire(baseDir = process.cwd()) {
+  return createRequire(path.join(baseDir, "package.json"));
+}
+function resolvePackageDir(packageName, baseDir = process.cwd()) {
+  const require2 = createPackageRequire(baseDir);
+  const entryPath = require2.resolve(packageName);
+  return path.dirname(path.dirname(entryPath));
+}
+async function checkChromeDevToolsAvailable(port = CHROME_DEVTOOLS_PORT, timeout = CHROME_DEVTOOLS_CHECK_TIMEOUT) {
+  const net = await import("net");
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, timeout);
+    socket.connect(port, "localhost", () => {
+      clearTimeout(timer);
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+async function isPortAvailable(port, hostname) {
+  const net = await import("net");
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port, hostname);
+  });
+}
+async function findAvailablePort(startPort, hostname, maxTries = 100) {
+  for (let port = startPort; port < startPort + maxTries; port++) {
+    if (await isPortAvailable(port, hostname)) return port;
+  }
+  throw new Error(`No available port in range ${startPort}-${startPort + maxTries}`);
+}
+export {
+  checkChromeDevToolsAvailable,
+  createPackageRequire,
+  findAvailablePort,
+  isPortAvailable,
+  resolvePackageDir
+};

package/es/node.d.ts

@@ -0,0 +1,6 @@
+export * from "./constants";
+export * from "./logger-core";
+export * from "./node-logger";
+export * from "./process-logger";
+export * from "./file-log-watcher";
+export * from "./node-utils";

package/es/node.mjs

@@ -0,0 +1,6 @@
+export * from "./constants.mjs";
+export * from "./logger-core.mjs";
+export * from "./node-logger.mjs";
+export * from "./process-logger.mjs";
+export * from "./file-log-watcher.mjs";
+export * from "./node-utils.mjs";

package/es/options.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 插件通用配置（Provider 无关）
+ * Provider 专属配置通过泛型 P 注入，核心层不感知具体 schema。
+ */
+import type { DisplayMode, LogFileConfig, SplitModeOptions } from "./types";
+/**
+ * 插件配置选项
+ * @typeParam P - 当前 Provider 的专属配置段（schema 由具体 Provider 声明）
+ */
+export interface PluginOptions<P extends Record<string, unknown> = Record<string, unknown>> {
+    /** 是否启用插件，默认 true */
+    enabled?: boolean;
+    /** 选择的 Web Provider 标识，默认 "default" */
+    provider?: string;
+    /** Web 服务端口，默认 5097 */
+    webPort?: number;
+    /** 代理服务端口，默认 6097 */
+    proxyPort?: number;
+    /** 服务主机名，默认 '127.0.0.1' */
+    hostname?: string;
+    /** 挂件位置，默认 'bottom-right' */
+    position?: "bottom-right" | "bottom-left" | "top-right" | "top-left";
+    /** 主题模式，默认 'dark' */
+    theme?: "light" | "dark" | "auto";
+    /** 是否自动打开面板，默认 false */
+    open?: boolean;
+    /** 是否输出详细日志，默认 false */
+    verbose?: boolean;
+    /** 纯净 MCP 模式：只暴露 MCP 工具服务，不注入挂件、不启动 provider Web 进程，默认为 false */
+    mcpOnly?: boolean;
+    /** 快捷键配置，默认 'ctrl+k' */
+    hotkey?: string;
+    /** 服务启动后是否立即预热 Chrome MCP，默认 true */
+    warmupChromeMcp?: boolean;
+    /** Chrome DevTools Protocol 端口，默认 9222 */
+    chromeDevtoolsPort?: number;
+    /** 展示模式，默认 'bubble' */
+    displayMode?: DisplayMode;
+    /** 分屏模式配置 */
+    splitMode?: SplitModeOptions;
+    /** 自定义日志文件配置，为 Agent 提供查看外部服务日志的能力 */
+    logFiles?: LogFileConfig[];
+    /** Provider 专属配置段（schema 由具体 Provider 声明，核心层不感知） */
+    providerOptions?: P;
+    /** @deprecated 使用 providerOptions.language */
+    language?: string;
+    /** @deprecated 使用 providerOptions.settings */
+    settings?: unknown;
+    /** @deprecated 使用 providerOptions.enableLsp */
+    enableLsp?: boolean;
+    /** @deprecated 使用 providerOptions.enableBlockOnError */
+    enableBlockOnError?: boolean;
+    /** @deprecated 使用 providerOptions.enablePrettier */
+    enablePrettier?: boolean;
+}
+/** 插件通用配置默认值（Provider 无关部分） */
+export declare const DEFAULT_PLUGIN_OPTIONS: Partial<PluginOptions>;
+/**
+ * 组装运行时配置（通用默认 + 用户配置）
+ * Provider 专属段原样合并透传，schema 由 Provider 自行解析；
+ * deprecated 顶层字段不在此迁移，保留在 config 顶层，由 Provider 读取兜底。
+ */
+export declare function resolvePluginConfig<P extends Record<string, unknown> = Record<string, unknown>>(options?: PluginOptions<P>): Required<PluginOptions<P>>;

package/es/options.mjs

@@ -0,0 +1,30 @@
+import { CHROME_DEVTOOLS_PORT, DEFAULT_HOSTNAME, DEFAULT_WEB_PORT } from "./constants.mjs";
+const DEFAULT_PLUGIN_OPTIONS = {
+  enabled: true,
+  provider: "default",
+  webPort: DEFAULT_WEB_PORT,
+  hostname: DEFAULT_HOSTNAME,
+  theme: "dark",
+  open: false,
+  verbose: false,
+  mcpOnly: false,
+  hotkey: "ctrl+k",
+  warmupChromeMcp: true,
+  chromeDevtoolsPort: CHROME_DEVTOOLS_PORT,
+  displayMode: "extension",
+  splitMode: void 0,
+  providerOptions: void 0
+};
+function resolvePluginConfig(options = {}) {
+  return {
+    ...DEFAULT_PLUGIN_OPTIONS,
+    ...options,
+    providerOptions: {
+      ...options.providerOptions ?? {}
+    }
+  };
+}
+export {
+  DEFAULT_PLUGIN_OPTIONS,
+  resolvePluginConfig
+};

package/es/process-logger.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @fileoverview 进程日志捕获器
+ * @description 拦截 console 方法并存储日志到内存缓冲区，供 agent 通过工具获取
+ */
+export interface ProcessLogEntry {
+    /** 日志级别 */
+    level: "log" | "info" | "warn" | "error" | "debug";
+    /** 日志内容（已序列化为字符串） */
+    message: string;
+    /** 时间戳（ISO 格式） */
+    timestamp: string;
+    /** 来源标识 */
+    source?: "console" | "provider-stdout" | "provider-stderr" | "vite";
+}
+export interface ProcessLogBufferOptions {
+    /** 最大日志条数，默认 500 */
+    maxSize?: number;
+    /** 是否启用捕获，默认 true */
+    enabled?: boolean;
+}
+/**
+ * 进程日志缓冲区
+ */
+declare class ProcessLogBuffer {
+    private buffer;
+    private maxSize;
+    private enabled;
+    private originalConsole;
+    constructor(options?: ProcessLogBufferOptions);
+    /**
+     * 启动 console 拦截
+     */
+    intercept(): void;
+    /**
+     * 停止拦截，恢复原始 console
+     */
+    restore(): void;
+    /**
+     * 创建拦截器函数
+     */
+    private createInterceptor;
+    /**
+     * 序列化参数为字符串
+     */
+    private serializeArgs;
+    /**
+     * 添加日志条目
+     */
+    addEntry(entry: ProcessLogEntry): void;
+    /**
+     * 添加 Provider stdout 日志
+     */
+    addProviderStdout(message: string): void;
+    /**
+     * 添加 Provider stderr 日志
+     */
+    addProviderStderr(message: string): void;
+    /**
+     * 获取日志
+     * @param options 过滤选项
+     */
+    getLogs(options?: {
+        level?: ProcessLogEntry["level"] | ProcessLogEntry["level"][];
+        limit?: number;
+        source?: ProcessLogEntry["source"];
+        since?: string;
+    }): ProcessLogEntry[];
+    /**
+     * 清空缓冲区
+     */
+    clear(): void;
+    /**
+     * 获取缓冲区大小
+     */
+    size(): number;
+    /**
+     * 启用/禁用捕获
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 获取是否启用
+     */
+    isEnabled(): boolean;
+}
+/**
+ * 获取全局日志缓冲区
+ */
+export declare function getProcessLogBuffer(options?: ProcessLogBufferOptions): ProcessLogBuffer;
+/**
+ * 初始化进程日志捕获
+ */
+export declare function initProcessLogCapture(options?: ProcessLogBufferOptions): ProcessLogBuffer;
+/**
+ * 停止进程日志捕获
+ */
+export declare function stopProcessLogCapture(): void;
+export {};