@ant-design/agentic-ui 2.0.0

package/dist/utils/proxySandbox/SecurityContextManager.d.ts

@@ -0,0 +1,183 @@
+/**
+ * 安全上下文管理器
+ *
+ * 提供更细粒度的安全控制，管理沙箱内的执行上下文，
+ * 包括变量作用域、API 权限、资源限制等。
+ *
+ * @author md-editor
+ * @version 1.0.0
+ */
+import { SandboxConfig, SandboxResult } from './ProxySandbox';
+/**
+ * 权限配置接口
+ */
+export interface PermissionConfig {
+    /** 是否允许网络请求 */
+    network: boolean;
+    /** 是否允许文件操作 */
+    fileSystem: boolean;
+    /** 是否允许摄像头/麦克风访问 */
+    media: boolean;
+    /** 是否允许地理位置访问 */
+    geolocation: boolean;
+    /** 是否允许通知 */
+    notifications: boolean;
+}
+/**
+ * 资源限制接口
+ */
+export interface ResourceLimits {
+    /** 最大执行时间 */
+    maxExecutionTime: number;
+    /** 最大内存使用 */
+    maxMemoryUsage: number;
+    /** 最大调用栈深度 */
+    maxCallStackDepth: number;
+    /** 最大循环次数 */
+    maxLoopIterations: number;
+}
+/**
+ * 监控配置接口
+ */
+export interface MonitoringConfig {
+    /** 是否启用性能监控 */
+    enablePerformanceMonitoring: boolean;
+    /** 是否启用错误追踪 */
+    enableErrorTracking: boolean;
+    /** 是否启用资源使用监控 */
+    enableResourceMonitoring: boolean;
+}
+/**
+ * 安全上下文配置接口
+ */
+export interface SecurityContextConfig extends SandboxConfig {
+    /** API 权限配置 */
+    permissions?: Partial<PermissionConfig>;
+    /** 资源限制 */
+    limits?: Partial<ResourceLimits>;
+    /** 监控配置 */
+    monitoring?: Partial<MonitoringConfig>;
+}
+/**
+ * 执行上下文信息
+ */
+export interface ExecutionContext {
+    /** 上下文 ID */
+    id: string;
+    /** 创建时间 */
+    createdAt: number;
+    /** 变量作用域 */
+    scope: Record<string, any>;
+    /** 权限设置 */
+    permissions: PermissionConfig;
+    /** 资源使用情况 */
+    resourceUsage: {
+        memoryUsage: number;
+        executionTime: number;
+        callStackDepth: number;
+        loopIterations: number;
+    };
+}
+/**
+ * 安全上下文管理器类
+ */
+export declare class SecurityContextManager {
+    private contexts;
+    private config;
+    private globalMonitors;
+    constructor(config?: SecurityContextConfig);
+    /**
+     * 合并默认配置
+     */
+    private mergeDefaultConfig;
+    /**
+     * 初始化全局监控器
+     */
+    private initializeGlobalMonitors;
+    /**
+     * 创建性能监控器
+     */
+    private createPerformanceMonitor;
+    /**
+     * 创建错误追踪器
+     */
+    private createErrorTracker;
+    /**
+     * 创建资源监控器
+     */
+    private createResourceMonitor;
+    /**
+     * 创建新的执行上下文
+     */
+    createContext(contextId?: string): string;
+    /**
+     * 生成上下文 ID
+     */
+    private generateContextId;
+    /**
+     * 获取执行上下文
+     */
+    getContext(contextId: string): ExecutionContext | undefined;
+    /**
+     * 删除执行上下文
+     */
+    deleteContext(contextId: string): boolean;
+    /**
+     * 在指定上下文中执行代码
+     */
+    executeInContext(contextId: string, code: string, additionalScope?: Record<string, any>): Promise<SandboxResult>;
+    /**
+     * 包装代码以添加监控
+     */
+    private wrapCodeWithMonitoring;
+    /**
+     * 更新上下文的资源使用情况
+     */
+    private updateContextResourceUsage;
+    /**
+     * 检查资源限制
+     */
+    private checkResourceLimits;
+    /**
+     * 设置上下文变量
+     */
+    setContextVariable(contextId: string, name: string, value: any): boolean;
+    /**
+     * 获取上下文变量
+     */
+    getContextVariable(contextId: string, name: string): any;
+    /**
+     * 清理所有上下文
+     */
+    clearAllContexts(): void;
+    /**
+     * 获取所有上下文的统计信息
+     */
+    getStatistics(): {
+        totalContexts: number;
+        totalMemoryUsage: number;
+        totalExecutionTime: number;
+        averageExecutionTime: number;
+        oldestContext: ExecutionContext;
+    };
+    /**
+     * 获取管理器配置
+     */
+    getConfig(): {
+        permissions: PermissionConfig;
+        limits: ResourceLimits;
+        monitoring: MonitoringConfig;
+    } & Required<SandboxConfig>;
+    /**
+     * 销毁管理器
+     */
+    destroy(): void;
+}
+/**
+ * 创建安全上下文管理器的工厂函数
+ */
+export declare function createSecurityContextManager(config?: SecurityContextConfig): SecurityContextManager;
+/**
+ * 快速在受控环境中执行代码的工具函数
+ */
+export declare function runInSecureContext(code: string, config?: SecurityContextConfig, contextScope?: Record<string, any>): Promise<SandboxResult>;

package/dist/utils/proxySandbox/SecurityContextManager.js

@@ -0,0 +1,369 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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());
+  });
+};
+
+// src/utils/proxySandbox/SecurityContextManager.ts
+import { ProxySandbox } from "./ProxySandbox";
+var SecurityContextManager = class {
+  constructor(config = {}) {
+    this.contexts = /* @__PURE__ */ new Map();
+    this.globalMonitors = /* @__PURE__ */ new Map();
+    this.config = this.mergeDefaultConfig(config);
+    this.initializeGlobalMonitors();
+  }
+  /**
+   * 合并默认配置
+   */
+  mergeDefaultConfig(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+    return {
+      // 继承沙箱配置
+      allowedGlobals: config.allowedGlobals || [],
+      forbiddenGlobals: config.forbiddenGlobals || [],
+      allowConsole: (_a = config.allowConsole) != null ? _a : true,
+      allowTimers: (_b = config.allowTimers) != null ? _b : true,
+      timeout: config.timeout || 5e3,
+      strictMode: (_c = config.strictMode) != null ? _c : true,
+      customGlobals: config.customGlobals || {},
+      allowDOM: (_d = config.allowDOM) != null ? _d : false,
+      maxMemoryUsage: config.maxMemoryUsage || 10 * 1024 * 1024,
+      // 权限配置
+      permissions: {
+        network: (_f = (_e = config.permissions) == null ? void 0 : _e.network) != null ? _f : false,
+        fileSystem: (_h = (_g = config.permissions) == null ? void 0 : _g.fileSystem) != null ? _h : false,
+        media: (_j = (_i = config.permissions) == null ? void 0 : _i.media) != null ? _j : false,
+        geolocation: (_l = (_k = config.permissions) == null ? void 0 : _k.geolocation) != null ? _l : false,
+        notifications: (_n = (_m = config.permissions) == null ? void 0 : _m.notifications) != null ? _n : false
+      },
+      // 资源限制
+      limits: {
+        maxExecutionTime: ((_o = config.limits) == null ? void 0 : _o.maxExecutionTime) || 5e3,
+        maxMemoryUsage: ((_p = config.limits) == null ? void 0 : _p.maxMemoryUsage) || 10 * 1024 * 1024,
+        maxCallStackDepth: ((_q = config.limits) == null ? void 0 : _q.maxCallStackDepth) || 100,
+        maxLoopIterations: ((_r = config.limits) == null ? void 0 : _r.maxLoopIterations) || 1e4
+      },
+      // 监控配置
+      monitoring: {
+        enablePerformanceMonitoring: (_t = (_s = config.monitoring) == null ? void 0 : _s.enablePerformanceMonitoring) != null ? _t : true,
+        enableErrorTracking: (_v = (_u = config.monitoring) == null ? void 0 : _u.enableErrorTracking) != null ? _v : true,
+        enableResourceMonitoring: (_x = (_w = config.monitoring) == null ? void 0 : _w.enableResourceMonitoring) != null ? _x : true
+      }
+    };
+  }
+  /**
+   * 初始化全局监控器
+   */
+  initializeGlobalMonitors() {
+    if (this.config.monitoring.enablePerformanceMonitoring) {
+      this.globalMonitors.set("performance", this.createPerformanceMonitor());
+    }
+    if (this.config.monitoring.enableErrorTracking) {
+      this.globalMonitors.set("errorTracker", this.createErrorTracker());
+    }
+    if (this.config.monitoring.enableResourceMonitoring) {
+      this.globalMonitors.set("resourceMonitor", this.createResourceMonitor());
+    }
+  }
+  /**
+   * 创建性能监控器
+   */
+  createPerformanceMonitor() {
+    return {
+      mark: (name) => {
+        if (typeof performance !== "undefined" && performance.mark) {
+          performance.mark(`sandbox-${name}`);
+        }
+      },
+      measure: (name, startMark, endMark) => {
+        if (typeof performance !== "undefined" && performance.measure) {
+          try {
+            performance.measure(
+              name,
+              `sandbox-${startMark}`,
+              `sandbox-${endMark}`
+            );
+          } catch (error) {
+            console.warn("Performance measurement failed:", error);
+          }
+        }
+      }
+    };
+  }
+  /**
+   * 创建错误追踪器
+   */
+  createErrorTracker() {
+    return {
+      captureError: (error, context) => {
+        console.error(`[Sandbox Error] ${context}:`, error);
+      },
+      captureWarning: (message, context) => {
+        console.warn(`[Sandbox Warning] ${context}: ${message}`);
+      }
+    };
+  }
+  /**
+   * 创建资源监控器
+   */
+  createResourceMonitor() {
+    return {
+      checkMemoryUsage: () => {
+        if (typeof performance !== "undefined" && performance.memory) {
+          return performance.memory.usedJSHeapSize;
+        }
+        return 0;
+      },
+      checkCallStackDepth: (stack) => {
+        var _a;
+        if (stack) {
+          return stack.split("\n").length;
+        }
+        try {
+          throw new Error();
+        } catch (e) {
+          return ((_a = e.stack) == null ? void 0 : _a.split("\n").length) || 0;
+        }
+      }
+    };
+  }
+  /**
+   * 创建新的执行上下文
+   */
+  createContext(contextId) {
+    const id = contextId || this.generateContextId();
+    const context = {
+      id,
+      createdAt: Date.now(),
+      scope: {},
+      permissions: {
+        network: this.config.permissions.network,
+        fileSystem: this.config.permissions.fileSystem,
+        media: this.config.permissions.media,
+        geolocation: this.config.permissions.geolocation,
+        notifications: this.config.permissions.notifications
+      },
+      resourceUsage: {
+        memoryUsage: 0,
+        executionTime: 0,
+        callStackDepth: 0,
+        loopIterations: 0
+      }
+    };
+    this.contexts.set(id, context);
+    return id;
+  }
+  /**
+   * 生成上下文 ID
+   */
+  generateContextId() {
+    return `ctx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * 获取执行上下文
+   */
+  getContext(contextId) {
+    return this.contexts.get(contextId);
+  }
+  /**
+   * 删除执行上下文
+   */
+  deleteContext(contextId) {
+    return this.contexts.delete(contextId);
+  }
+  /**
+   * 在指定上下文中执行代码
+   */
+  executeInContext(_0, _1) {
+    return __async(this, arguments, function* (contextId, code, additionalScope = {}) {
+      const context = this.getContext(contextId);
+      if (!context) {
+        throw new Error(`Context ${contextId} not found`);
+      }
+      const mergedScope = __spreadValues(__spreadValues({}, context.scope), additionalScope);
+      const sandboxConfig = {
+        allowedGlobals: this.config.allowedGlobals,
+        forbiddenGlobals: this.config.forbiddenGlobals,
+        allowConsole: this.config.allowConsole,
+        allowTimers: this.config.allowTimers,
+        timeout: this.config.limits.maxExecutionTime,
+        strictMode: this.config.strictMode,
+        customGlobals: __spreadValues(__spreadProps(__spreadValues(__spreadValues({}, this.config.customGlobals), mergedScope), {
+          // 添加上下文相关的全局变量
+          __context: {
+            id: contextId,
+            permissions: context.permissions
+          }
+        }), this.config.monitoring.enablePerformanceMonitoring && {
+          __performance: this.globalMonitors.get("performance")
+        }),
+        allowDOM: this.config.allowDOM,
+        maxMemoryUsage: this.config.limits.maxMemoryUsage
+      };
+      const wrappedCode = this.wrapCodeWithMonitoring(code);
+      const sandbox = new ProxySandbox(sandboxConfig);
+      try {
+        const result = yield sandbox.execute(wrappedCode);
+        this.updateContextResourceUsage(context, result);
+        return result;
+      } finally {
+        sandbox.destroy();
+      }
+    });
+  }
+  /**
+   * 包装代码以添加监控
+   */
+  wrapCodeWithMonitoring(code) {
+    if (!this.config.monitoring.enableResourceMonitoring) {
+      return code;
+    }
+    return code;
+  }
+  /**
+   * 更新上下文的资源使用情况
+   */
+  updateContextResourceUsage(context, result) {
+    context.resourceUsage.executionTime = result.executionTime;
+    context.resourceUsage.memoryUsage = result.memoryUsage || 0;
+    this.checkResourceLimits(context);
+  }
+  /**
+   * 检查资源限制
+   */
+  checkResourceLimits(context) {
+    const { resourceUsage } = context;
+    const { limits } = this.config;
+    if (resourceUsage.executionTime > limits.maxExecutionTime) {
+      throw new Error(
+        `Execution time limit exceeded: ${resourceUsage.executionTime}ms > ${limits.maxExecutionTime}ms`
+      );
+    }
+    if (resourceUsage.memoryUsage > limits.maxMemoryUsage) {
+      throw new Error(
+        `Memory usage limit exceeded: ${resourceUsage.memoryUsage} > ${limits.maxMemoryUsage}`
+      );
+    }
+    if (resourceUsage.callStackDepth > limits.maxCallStackDepth) {
+      throw new Error(
+        `Call stack depth limit exceeded: ${resourceUsage.callStackDepth} > ${limits.maxCallStackDepth}`
+      );
+    }
+  }
+  /**
+   * 设置上下文变量
+   */
+  setContextVariable(contextId, name, value) {
+    const context = this.getContext(contextId);
+    if (!context) {
+      return false;
+    }
+    context.scope[name] = value;
+    return true;
+  }
+  /**
+   * 获取上下文变量
+   */
+  getContextVariable(contextId, name) {
+    const context = this.getContext(contextId);
+    return context == null ? void 0 : context.scope[name];
+  }
+  /**
+   * 清理所有上下文
+   */
+  clearAllContexts() {
+    this.contexts.clear();
+  }
+  /**
+   * 获取所有上下文的统计信息
+   */
+  getStatistics() {
+    const contexts = Array.from(this.contexts.values());
+    return {
+      totalContexts: contexts.length,
+      totalMemoryUsage: contexts.reduce(
+        (sum, ctx) => sum + ctx.resourceUsage.memoryUsage,
+        0
+      ),
+      totalExecutionTime: contexts.reduce(
+        (sum, ctx) => sum + ctx.resourceUsage.executionTime,
+        0
+      ),
+      averageExecutionTime: contexts.length > 0 ? contexts.reduce(
+        (sum, ctx) => sum + ctx.resourceUsage.executionTime,
+        0
+      ) / contexts.length : 0,
+      oldestContext: contexts.reduce(
+        (oldest, ctx) => ctx.createdAt < oldest.createdAt ? ctx : oldest,
+        contexts[0]
+      )
+    };
+  }
+  /**
+   * 获取管理器配置
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * 销毁管理器
+   */
+  destroy() {
+    this.clearAllContexts();
+    this.globalMonitors.clear();
+  }
+};
+function createSecurityContextManager(config) {
+  return new SecurityContextManager(config);
+}
+function runInSecureContext(code, config, contextScope) {
+  return __async(this, null, function* () {
+    const manager = createSecurityContextManager(config);
+    const contextId = manager.createContext();
+    try {
+      return yield manager.executeInContext(contextId, code, contextScope);
+    } finally {
+      manager.destroy();
+    }
+  });
+}
+export {
+  SecurityContextManager,
+  createSecurityContextManager,
+  runInSecureContext
+};

package/dist/utils/proxySandbox/index.d.ts

@@ -0,0 +1,57 @@
+import type { SandboxConfig } from './ProxySandbox';
+import { ProxySandbox } from './ProxySandbox';
+import type { SecurityContextConfig } from './SecurityContextManager';
+import { SecurityContextManager } from './SecurityContextManager';
+export { ProxySandbox, createSandbox, runInSandbox } from './ProxySandbox';
+export type { SandboxConfig, SandboxResult } from './ProxySandbox';
+export { SecurityContextManager, createSecurityContextManager, runInSecureContext, } from './SecurityContextManager';
+export type { ExecutionContext, MonitoringConfig, PermissionConfig, ResourceLimits, SecurityContextConfig, } from './SecurityContextManager';
+export type SandboxInstance = ProxySandbox;
+export type SecurityManager = SecurityContextManager;
+/**
+ * 默认的沙箱配置
+ */
+export declare const DEFAULT_SANDBOX_CONFIG: SandboxConfig;
+/**
+ * 默认的安全上下文配置
+ */
+export declare const DEFAULT_SECURITY_CONFIG: SecurityContextConfig;
+/**
+ * 沙箱工厂函数 - 创建配置好的沙箱实例
+ */
+export declare function createConfiguredSandbox(type?: 'basic' | 'secure' | 'restricted'): ProxySandbox;
+/**
+ * 快速执行简单代码的便捷函数
+ */
+export declare function quickExecute(code: string, customGlobals?: Record<string, any>, injectedParams?: Record<string, any>): Promise<any>;
+/**
+ * 执行数学表达式的安全计算器
+ */
+export declare function safeMathEval(expression: string): Promise<number>;
+/**
+ * 沙箱状态检查工具
+ */
+export declare class SandboxHealthChecker {
+    private static instance;
+    static getInstance(): SandboxHealthChecker;
+    /**
+     * 检查浏览器环境是否支持沙箱功能
+     */
+    checkEnvironmentSupport(): {
+        supported: boolean;
+        issues: string[];
+        recommendations: string[];
+    };
+    /**
+     * 测试沙箱基本功能
+     */
+    testBasicFunctionality(): Promise<{
+        passed: boolean;
+        results: Record<string, boolean>;
+        errors: string[];
+    }>;
+}
+/**
+ * 导出健康检查器实例
+ */
+export declare const sandboxHealthChecker: SandboxHealthChecker;