foliko 1.1.63 → 1.1.64

package/src/utils/retry.js

@@ -1,12 +1,42 @@
 /**
  * Foliko Retry Strategy - 重试策略系统
  * 提供多种重试策略，支持指数退避、抖动等
+ *
+ * 统一的重试入口，取代以下分散的重试逻辑：
+ * - ChatQueueManager.executeWithRetry() (utils/chat-queue.js)
+ * - Subagent.chat() 中的重试循环 (core/subagent.js)
+ * - utils/index.js 中的 retry() 函数
  */
 
 const { logger } = require('./logger');
 
 const log = logger.child('RetryStrategy');
 
+/**
+ * 网络错误码列表
+ */
+const NETWORK_ERROR_CODES = [
+  'ECONNREFUSED',
+  'ECONNRESET',
+  'ETIMEDOUT',
+  'ENOTFOUND',
+  'EAI_AGAIN',
+  'EPIPE',
+  'ERR_CONNECTION_REFUSED',
+  'ERR_CONNECTION_RESET',
+  'ERR_CONNECTION_TIMEOUT',
+];
+
+/**
+ * API 可重试的 HTTP 状态码
+ */
+const RETRYABLE_HTTP_CODES = [429, 500, 502, 503, 504];
+
+/**
+ * AI SDK 错误名称（可重试）
+ */
+const AI_RETRYABLE_ERRORS = ['AI_RetryError', 'RetryError', 'AI_APICallError'];
+
 /**
  * 重试策略配置
  * @typedef {Object} RetryConfig
@@ -63,16 +93,32 @@ const PRESETS = {
     factor: 1.5,
     jitter: 0.05,
   },
-  /** 空闲连接保活（适合长时间运行的连接检查） */
-  idle: {
+  /** AI API 重试（包含 AI SDK 特定错误判断） */
+  ai: {
     maxAttempts: 3,
-    baseDelay: 5000,
+    baseDelay: 2000,
     maxDelay: 15000,
-    factor: 1.5,
-    jitter: 0.1,
+    factor: 2,
+    jitter: 0.2,
+    shouldRetry: (error) => {
+      if (!error) return false;
+      const name = error.name || '';
+      if (AI_RETRYABLE_ERRORS.includes(name)) return true;
+      // 也检查标准网络错误
+      return isNetworkError(error);
+    },
+  },
+  /** API 调用重试（适合第三方API） */
+  api: {
+    maxAttempts: 4,
+    baseDelay: 500,
+    maxDelay: 8000,
+    factor: 2,
+    jitter: 0.15,
     shouldRetry: (error) => {
-      const networkCodes = ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND'];
-      return error.code && networkCodes.includes(error.code);
+      const status = error.status || error.statusCode;
+      if (status && (status >= 500 || status === 429)) return true;
+      return isNetworkError(error);
     },
   },
   /** 数据库重试（适合数据库连接） */
@@ -104,19 +150,119 @@ const PRESETS = {
       return dbKeywords.some((k) => msg.includes(k));
     },
   },
-  /** API调用重试（适合第三方API） */
-  api: {
-    maxAttempts: 4,
-    baseDelay: 500,
-    maxDelay: 8000,
-    factor: 2,
-    jitter: 0.15,
-    shouldRetry: (error) => {
-      const status = error.status || error.statusCode;
-      if (status && (status >= 500 || status === 429)) return true;
-      const networkCodes = ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND'];
-      if (error.code && networkCodes.includes(error.code)) return true;
-      return false;
-    },
-  },
+};
+
+/**
+ * 判断错误是否由网络/AI服务问题引起（统一入口）
+ * 替代 ChatQueueManager.isRetryableError() 和 Subagent 中的分类逻辑
+ * @param {Error} err
+ * @returns {boolean}
+ */
+function isNetworkError(err) {
+  if (!err) return false;
+
+  const code = err.code || err.status || err.statusCode;
+  const message = (err.message || '').toLowerCase();
+  const name = err.name || '';
+
+  // 检查网络错误码
+  if (code && NETWORK_ERROR_CODES.includes(code)) return true;
+
+  // 检查可重试 HTTP 状态码
+  if (typeof code === 'number' && RETRYABLE_HTTP_CODES.includes(code)) return true;
+
+  // 检查 AI SDK 重试错误
+  if (AI_RETRYABLE_ERRORS.includes(name)) return true;
+
+  // 检查消息关键词
+  const retryableKeywords = [
+    'timeout', 'network', 'econnrefused', 'econnreset', 'etimedout',
+    'enotfound', 'rate limit', '负载较高', '暂时不可用',
+    '429', '500', '502', '503', '504',
+  ];
+  return retryableKeywords.some((kw) => message.includes(kw));
+}
+
+/**
+ * 计算下次重试延迟（指数退避 + 随机抖动）
+ * @param {number} attempt - 当前尝试次数（从 1 开始）
+ * @param {RetryConfig} config - 重试配置
+ * @returns {number} 延迟毫秒数
+ */
+function calculateDelay(attempt, config = {}) {
+  const factor = config.factor || 2;
+  const baseDelay = config.baseDelay || 1000;
+  const maxDelay = config.maxDelay || 30000;
+  const jitter = config.jitter ?? 0.2;
+
+  // 指数退避: baseDelay * factor ^ (attempt - 1)
+  const exponentialDelay = baseDelay * Math.pow(factor, attempt - 1);
+
+  // 加上抖动: delay * (1 + random(-jitter, +jitter))
+  const jitterAmount = exponentialDelay * jitter * (Math.random() * 2 - 1);
+  const delay = Math.min(exponentialDelay + jitterAmount, maxDelay);
+
+  return Math.max(delay, 0);
+}
+
+/**
+ * 带重试策略的函数执行
+ * @param {Function} fn - 要执行的异步函数
+ * @param {RetryConfig} [config] - 重试配置（默认 standard）
+ * @returns {Promise<any>}
+ * @throws {Error} 所有重试耗尽后抛出最后一次错误
+ */
+async function withRetry(fn, config = {}) {
+  const merged = { ...PRESETS.standard, ...config };
+  const { maxAttempts, onRetry } = merged;
+
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+
+      // 判断是否应重试
+      const shouldRetry = merged.shouldRetry || isNetworkError;
+      if (!shouldRetry(err)) {
+        throw err; // 不可重试的错误，立即抛出
+      }
+
+      if (attempt < maxAttempts) {
+        const delay = calculateDelay(attempt, merged);
+        if (onRetry) {
+          try { onRetry(err, attempt, delay); } catch { /* ignore */ }
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * 装饰器：使函数可重试
+ * @param {RetryConfig} [config]
+ * @returns {Function} 装饰后的函数
+ */
+function retryable(config = {}) {
+  return function (fn) {
+    return async (...args) => {
+      return withRetry(() => fn(...args), config);
+    };
+  };
+}
+
+module.exports = {
+  withRetry,
+  retryable,
+  isNetworkError,
+  calculateDelay,
+  PRESETS,
+  NETWORK_ERROR_CODES,
+  RETRYABLE_HTTP_CODES,
+  AI_RETRYABLE_ERRORS,
 };

package/src/utils/sandbox.js

@@ -1,10 +1,10 @@
 /**
  * 安全沙箱工具
- * 用于替代 new Function() 执行不可信代码
+ * 使用 Node.js 原生 vm 模块（替代已废弃的 vm2）
  * 提供安全的代码执行环境，限制对系统资源的访问
  */
 
-const { VM, VMScript } = require('vm2')
+const vm = require('vm');
 
 /**
  * 创建安全的沙箱上下文
@@ -13,272 +13,125 @@ const { VM, VMScript } = require('vm2')
  * @returns {Object} 沙箱上下文
  */
 function createSandboxContext(customContext = {}, options = {}) {
-  const {
-    timeout = 5000,        // 超时时间（毫秒）
-    allowSync = false,     // 是否允许同步执行
-    mockConsole = true      // 是否模拟 console
-  } = options
+  const { mockConsole = true } = options;
 
-  // 创建安全的 console 对象
-  const safeConsole = mockConsole ? {
-    log: (...args) => { /* 静默执行，阻止日志泄露 */ },
-    error: (...args) => { /* 静默执行 */ },
-    warn: (...args) => { /* 静默执行 */ },
-    info: (...args) => { /* 静默执行 */ },
-    debug: (...args) => { /* 静默执行 */ }
-  } : console
+  const safeConsole = mockConsole
+    ? { log() {}, error() {}, warn() {}, info() {}, debug() {} }
+    : console;
 
   return {
-    // 用户提供的上下文
     ...customContext,
-    // 安全的 console
     console: safeConsole,
-    // 安全的 Math 对象
     Math,
-    // 安全的 JSON 对象
-    JSON: {
-      parse: JSON.parse,
-      stringify: JSON.stringify
-    },
-    // 安全的 Array 对象（限制方法）
-    Array: {
-      isArray: Array.isArray,
-      from: Array.from,
-      of: Array.of
-    },
-    // 安全的 String 对象
-    String: {
-      fromCharCode: String.fromCharCode,
-      fromCodePoint: String.fromCodePoint,
-      raw: String.raw
-    },
-    // 安全的 Number 对象
-    Number: {
-      isNaN: Number.isNaN,
-      isFinite: Number.isFinite,
-      parseInt: Number.parseInt,
-      parseFloat: Number.parseFloat
-    },
-    // 安全的 Boolean 对象
+    JSON: { parse: JSON.parse, stringify: JSON.stringify },
+    Array: { isArray: Array.isArray, from: Array.from, of: Array.of },
+    String: { fromCharCode: String.fromCharCode, fromCodePoint: String.fromCodePoint, raw: String.raw },
+    Number: { isNaN: Number.isNaN, isFinite: Number.isFinite, parseInt: Number.parseInt, parseFloat: Number.parseFloat },
     Boolean,
-    // 安全的 Object 对象
-    Object: {
-      keys: Object.keys,
-      values: Object.values,
-      entries: Object.entries,
-      assign: Object.assign,
-      create: Object.create,
-      freeze: Object.freeze
-    },
-    // 安全的 Date 对象
-    Date: {
-      now: Date.now
-    },
-    // 安全的 RegExp 对象
+    Object: { keys: Object.keys, values: Object.values, entries: Object.entries, assign: Object.assign, create: Object.create, freeze: Object.freeze },
+    Date: { now: Date.now },
     RegExp,
-    // 安全的 Error 对象
     Error,
-    // 安全的 Promise 对象
     Promise,
-    // 安全的 Set 对象
     Set,
-    // 安全的 Map 对象
     Map,
-    // 安全的 WeakMap 对象
     WeakMap,
-    // 安全的 WeakSet 对象
     WeakSet,
-    // 安全的 Symbol
     Symbol,
-    // 安全的 Proxy
     Proxy,
-    // 安全的 Reflect
-    Reflect
-  }
+    Reflect,
+  };
 }
 
 /**
- * 在沙箱中执行异步代码
+ * 在沙箱中执行代码
  * @param {string} code - 要执行的代码
  * @param {Object} context - 上下文变量
  * @param {Object} options - 配置选项
+ * @param {number} options.timeout - 超时毫秒
  * @returns {Promise<any>} 执行结果
  */
 async function runInSandbox(code, context = {}, options = {}) {
-  const { timeout = 5000 } = options
-
+  const { timeout = 5000 } = options;
   try {
-    const vm = new VM({
-      timeout,
-      sandbox: createSandboxContext(context, options),
-      eval: false,
-      wasm: false
-    })
-
-    // 包装代码为异步函数
-    const wrappedCode = `(async () => { ${code} })()`
-    return await vm.run(wrappedCode)
+    const ctx = vm.createContext(createSandboxContext(context, options));
+    const script = new vm.Script(`(async () => { ${code} })()`, { filename: 'sandbox.js' });
+    return await script.runInContext(ctx, { timeout });
   } catch (error) {
-    throw new Error(`Sandbox execution error: ${error.message}`)
+    throw new Error(`Sandbox execution error: ${error.message}`);
   }
 }
 
 /**
  * 在沙箱中执行表达式（同步）
- * @param {string} expression - 要执行的表达式
- * @param {Object} context - 上下文变量
- * @param {Object} options - 配置选项
- * @returns {any} 执行结果
  */
 function evaluateInSandbox(expression, context = {}, options = {}) {
-  const { timeout = 5000 } = options
-
+  const { timeout = 5000 } = options;
   try {
-    const vm = new VM({
-      timeout,
-      sandbox: createSandboxContext(context, options),
-      eval: false,
-      wasm: false
-    })
-
-    return vm.run(expression)
+    const ctx = vm.createContext(createSandboxContext(context, options));
+    return vm.runInContext(expression, ctx, { timeout });
   } catch (error) {
-    throw new Error(`Sandbox evaluation error: ${error.message}`)
+    throw new Error(`Sandbox evaluation error: ${error.message}`);
   }
 }
 
 /**
  * 安全执行脚本（用于工作流中的用户脚本）
- * @param {string} script - 脚本代码
- * @param {Object} context - 上下文变量
- * @param {Object} options - 配置选项
- * @returns {Promise<any>} 执行结果
  */
 async function runScriptSafely(script, context = {}, options = {}) {
-  const { timeout = 10000 } = options
-
+  const { timeout = 10000 } = options;
   try {
-    const vm = new VM({
-      timeout,
-      sandbox: createSandboxContext(context, options),
-      eval: false,
-      wasm: false
-    })
-
-    // 将脚本包装在异步 IIFE 中
-    const wrappedCode = `
-      (async () => {
-        const { input, input_data, variables, previousResult, console } = context;
-        ${script}
-      })()
-    `
-
-    return await vm.run(wrappedCode)
+    const ctx = vm.createContext(createSandboxContext(context, options));
+    const wrapped = `(async () => { ${script} })()`;
+    const s = new vm.Script(wrapped, { filename: 'script.js' });
+    return await s.runInContext(ctx, { timeout });
   } catch (error) {
-    throw new Error(`Script execution error: ${error.message}`)
+    throw new Error(`Script execution error: ${error.message}`);
   }
 }
 
 /**
  * 安全执行工作流定义
- * @param {string} workflowCode - 工作流代码
- * @param {Object} engine - 工作流引擎
- * @param {Object} options - 配置选项
- * @returns {any} 执行结果
  */
 function runWorkflowSafely(workflowCode, engine, options = {}) {
-  const { timeout = 5000 } = options
-
+  const { timeout = 5000 } = options;
   try {
-    const vm = new VM({
-      timeout,
-      sandbox: {
-        engine,
-        console: {
-          log: () => {},
-          error: () => {},
-          warn: () => {},
-          info: () => {}
-        },
-        Math,
-        JSON,
-        Promise,
-        Array,
-        Object,
-        Date,
-        RegExp,
-        Error,
-        Symbol,
-        Map,
-        Set
-      },
-      eval: false,
-      wasm: false
-    })
-
-    return vm.run(`(function(engine) { return (${workflowCode}) })(engine)`)
+    const ctx = vm.createContext({
+      engine,
+      console: { log() {}, error() {}, warn() {}, info() {} },
+      Math, JSON, Promise, Array, Object, Date, RegExp, Error, Symbol, Map, Set,
+    });
+    const wrapped = `(function(engine) { return (${workflowCode}) })(engine)`;
+    return vm.runInContext(wrapped, ctx, { timeout });
   } catch (error) {
-    throw new Error(`Workflow execution error: ${error.message}`)
+    throw new Error(`Workflow execution error: ${error.message}`);
   }
 }
 
 /**
  * 安全执行工作流加载脚本
- * @param {string} content - 文件内容
- * @param {Object} options - 配置选项
- * @returns {Object} module.exports
  */
 function runWorkflowFileSafely(content, options = {}) {
-  const { timeout = 10000 } = options
-
+  const { timeout = 10000 } = options;
   try {
-    const vm = new VM({
-      timeout,
-      sandbox: {
-        module: { exports: {} },
-        exports: {},
-        require: () => { throw new Error('require is not allowed in sandbox') },
-        process: { 
-          env: {},
-          cwd: () => '/'
-        },
-        console: {
-          log: () => {},
-          error: () => {},
-          warn: () => {},
-          info: () => {}
-        },
-        __dirname: '/',
-        __filename: '/workflow.js',
-        Math,
-        JSON,
-        Promise,
-        Array,
-        Object,
-        Date,
-        RegExp,
-        Error,
-        Symbol,
-        Map,
-        Set
-      },
-      eval: false,
-      wasm: false
-    })
-
-    const wrappedCode = `
-      (function(module, exports, require, process, console, __dirname, __filename) {
-        ${content}
-      })
-    `
-
-    const fn = vm.run(wrappedCode)
-    const moduleObj = { exports: {} }
-    fn(moduleObj, moduleObj.exports, () => {}, { env: {}, cwd: () => '/' }, { log: () => {}, error: () => {}, warn: () => {}, info: () => {} }, '/', '/workflow.js')
-    
-    return moduleObj.exports.default || moduleObj.exports
+    const ctx = vm.createContext({
+      module: { exports: {} },
+      exports: {},
+      require: () => { throw new Error('require is not allowed in sandbox'); },
+      process: { env: {}, cwd: () => '/' },
+      console: { log() {}, error() {}, warn() {}, info() {} },
+      __dirname: '/',
+      __filename: '/workflow.js',
+      Math, JSON, Promise, Array, Object, Date, RegExp, Error, Symbol, Map, Set,
+    });
+
+    const wrapped = `(function(module, exports, require, process, console, __dirname, __filename) { ${content} })`;
+    const fn = vm.runInContext(wrapped, ctx, { timeout });
+    const m = { exports: {} };
+    fn(m, m.exports, () => {}, { env: {}, cwd: () => '/' }, { log() {}, error() {}, warn() {}, info() {} }, '/', '/workflow.js');
+    return m.exports.default || m.exports;
   } catch (error) {
-    throw new Error(`Workflow file execution error: ${error.message}`)
+    throw new Error(`Workflow file execution error: ${error.message}`);
   }
 }
 
@@ -288,5 +141,5 @@ module.exports = {
   evaluateInSandbox,
   runScriptSafely,
   runWorkflowSafely,
-  runWorkflowFileSafely
-}
+  runWorkflowFileSafely,
+};

package/cli/src/utils/debounce.js

@@ -1,106 +0,0 @@
-/**
- * 防抖函数 - 等待 delay 时间内没有新调用才执行
- * @param {Function} fn - 要防抖的函数
- * @param {number} delay - 延迟毫秒
- * @returns {{run: Function, cancel: Function}}
- */
-function debounce(fn, delay) {
-  let timer = null;
-
-  const debounced = (...args) => {
-    if (timer) {
-      clearTimeout(timer);
-    }
-    timer = setTimeout(() => {
-      fn(...args);
-      timer = null;
-    }, delay);
-  };
-
-  const cancel = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  };
-
-  return { run: debounced, cancel };
-}
-
-function throttle(fn, delay = 300, options = {}) {
-  let timer = null;
-  let lastTime = 0;
-  const { leading = true, trailing = true } = options;
-
-  return function (...args) {
-    const now = Date.now();
-
-    // 首次调用且不允许立即执行
-    if (!leading && lastTime === 0) {
-      lastTime = now;
-    }
-
-    // 距离下次执行还需要等待的时间
-    const remaining = delay - (now - lastTime);
-
-    if (remaining <= 0 || remaining > delay) {
-      // 可以立即执行
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      fn.apply(this, args);
-      lastTime = now;
-    } else if (!timer && trailing) {
-      // 设置定时器，确保最后一次调用能执行
-      timer = setTimeout(() => {
-        fn.apply(this, args);
-        lastTime = leading ? Date.now() : 0;
-        timer = null;
-      }, remaining);
-    }
-  };
-}
-
-/**
- * 间隔执行函数 - 每隔 interval 毫秒执行一次，直到被取消
- * @param {Function} fn - 要执行的函数
- * @param {number} interval - 间隔毫秒
- * @param {boolean} [lazy=false] - 如果为 true，start() 不会立即执行，只开始计时
- * @returns {{run: Function, cancel: Function}}
- */
-function interval(fn, intervalMs, lazy = false) {
-  let timer = null;
-
-  const start = () => {
-    // 先清除已存在的定时器
-    if (timer) {
-      clearInterval(timer);
-    }
-
-    // 如果不是 lazy 模式，立即执行一次
-    if (!lazy) {
-      fn();
-    }
-
-    // 设置间隔定时器
-    timer = setInterval(() => {
-      fn();
-    }, intervalMs);
-  };
-
-  const stop = () => {
-    if (timer) {
-      clearInterval(timer);
-      timer = null;
-    }
-  };
-
-  return { start, stop };
-}
-
-module.exports = {
-  debounce,
-  throttle,
-  interval,
-};