foliko 2.0.6 → 2.0.8

package/plugins/core/workflow/index.js

@@ -876,8 +876,8 @@ class WorkflowPlugin extends Plugin {
   constructor(config = {}) {
     super();
     this.name = 'workflow';
-    this.version = '1.0.0';
-    this.description = '工作流引擎，支持结构化工作流定义和执行';
+    this.version = '2.0.0';
+    this.description = '工作流引擎 v2（FlowEngine + JsonRunner + JsRunner + FlowContext）';
     this.priority = 6;
     this.system = true;
     this._framework = null;
@@ -907,7 +907,11 @@ class WorkflowPlugin extends Plugin {
       description: '执行指定的工作流',
       inputSchema: z.object({
         workflow: z.string().describe('工作流定义（JSON 或 JavaScript 代码）'),
-        input: z.object({}).optional().describe('工作流输入参数'),
+        // Use record(z.any()) rather than object({}) so callers can pass an
+        // object with arbitrary fields; default z.object({}) strips unknown
+        // keys (and here the schema is empty, so input would always end up
+        // as `{}` regardless of what was sent).
+        input: z.record(z.any()).optional().describe('工作流输入参数'),
       }),
       execute: async (args, framework) => {
         // 获取当前 sessionId
@@ -930,7 +934,16 @@ class WorkflowPlugin extends Plugin {
       description: '重载所有工作流，当用户添加或修改工作流后调用此工具',
       inputSchema: z.object({}),
       execute: async () => {
-        this.reload(this._framework);
+        // Forward to pluginManager.reload so the framework has a chance to
+        // refresh the plugin prototype (workflow_reload used to call
+        // this.reload() directly, but instance.reload() always runs against
+        // the prototype captured at construction time, ignoring code changes
+        // until the process restarts).
+        if (typeof framework.reloadPlugin === 'function') {
+          await framework.reloadPlugin('workflow');
+        } else {
+          this.reload(this._framework);
+        }
         return {
           success: true,
           data: `Workflows reloaded. Total: ${this._workflows.size}`,
@@ -994,15 +1007,48 @@ class WorkflowPlugin extends Plugin {
             let workflowDef;
             if (file.endsWith('.js')) {
               workflowDef = runWorkflowFileSafely(content, { timeout: 10000 });
+              if (workflowDef && typeof workflowDef === 'object' && typeof workflowDef.default === 'function') {
+                // ES module-style default export: { default: function($){...} }
+                workflowDef = workflowDef.default;
+              }
               if (typeof workflowDef === 'function') {
-                workflowDef = workflowDef(this._engine || {});
+                // Two JS workflow patterns are supported:
+                //   1. FLOW(function($) { $.push(...); $.next('start'); })
+                //      -> the exported value is a *factory* that must be called with engine
+                //   2. module.exports = function($) { $.push(...); $.next('start'); }
+                //      -> the exported value is the workflow function itself (not a factory)
+                //      -> it must NOT be called here; v2 JsRunner will invoke it with $ directly.
+                //      -> FLOW() can also export a factory directly if there's no surrounding
+                //         function body (raw expression form).
+                // We detect the factory form by looking for the literal `FLOW(` token
+                // in the file's source. When FLOW() is detected, we invoke it as factory.
+                if (/\bFLOW\s*\(/.test(content)) {
+                  try {
+                    workflowDef = workflowDef(this._engine || {});
+                    if (workflowDef && typeof workflowDef === 'object' && typeof workflowDef.default === 'function') {
+                      workflowDef = workflowDef.default;
+                    }
+                  } catch (err) {
+                    log.error(` Failed to call FLOW() factory for ${file}:`, err.message);
+                  }
+                }
+                // else: leave workflowDef as-is (it's already the workflow function)
               }
-              workflowDef = workflowDef.default || workflowDef;
             } else {
               workflowDef = JSON.parse(content);
             }
-            if (workflowDef && workflowDef.steps) {
+            // Accept either:
+            //   - JSON-style workflow with stages/flow field
+            //   - JS workflow exported as a function (Total.js style: FLOW(function($){...})
+            //     or module.exports = function($){...})
+            if (workflowDef && (workflowDef.stages || workflowDef.flow)) {
+              this._workflows.set(workflowName, workflowDef);
+            } else if (typeof workflowDef === 'function') {
+              // Store the JS function directly; v2 FlowEngine detects function type
+              // and dispatches to JsRunner.
               this._workflows.set(workflowName, workflowDef);
+            } else {
+              log.warn(`Skipping ${file}: not a recognized workflow definition (no stages/flow, and not a function)`);
             }
           } catch (err) {
             log.error(` Failed to load ${file}:`, err.message);
@@ -1018,9 +1064,17 @@ class WorkflowPlugin extends Plugin {
    */
   _registerWorkflowTools() {
     for (const [name, workflow] of this._workflows) {
-      if (this._workflowTools.has(name)) continue;
       const toolName = `workflow_${name}`;
       const description = workflow.description || `执行工作流: ${name}`;
+      // 注意：framework.registerTool 不做去重，导致 reload 后会有两个同名
+      // `workflow_<name>` 工具。getTool 返回第一个（旧的）。每次注册前先清掉。
+      if (this._framework?.toolRegistry?.unregisterTool) {
+        try {
+          this._framework.toolRegistry.unregisterTool(toolName);
+        } catch (e) {
+          // noop
+        }
+      }
       this._framework.registerTool({
         name: toolName,
         description,
@@ -1028,13 +1082,24 @@ class WorkflowPlugin extends Plugin {
           input: z.object({}).optional().describe('工作流输入参数'),
         }),
         execute: async (args, framework) => {
-          // Get current sessionId to ensure notifications reach the correct session
-          let sessionId = null;
-          const ctx = framework?.getExecutionContext?.();
-          if (ctx?.sessionId) {
-            sessionId = ctx.sessionId;
+          // 每次执行都从 this._workflows 重新查最新处理函数。
+          // 这样即使 ChatHandler 缓存了上个版本的 execute，我们仍能闭包到本对象上。
+          // 注意：ToolRegistry._tools.set 被调用后都是一个新的 execute 对象（闭包重新生成），
+          // 旧 execute 会因为 ChatHandler._aiToolsCache 不清而一直残留。
+          // 修复点：framework.registerTool现在会同步重设 ChatHandler 相关缓存。
+          let liveWorkflow;
+          try {
+            liveWorkflow = this._workflows.get(name);
+            if (!liveWorkflow) {
+              return { success: false, error: `Workflow '${name}' not loaded` };
+            }
+            let sessionId = null;
+            const ctx = framework?.getExecutionContext?.();
+            if (ctx?.sessionId) sessionId = ctx.sessionId;
+            return await this.executeWorkflow(liveWorkflow, args.input || {}, sessionId);
+          } catch (e) {
+            return { success: false, error: e.message, stack: e.stack };
           }
-          return await this.executeWorkflow(workflow, args.input || {}, sessionId);
         },
       });
       this._workflowTools.set(name, toolName);
@@ -1069,10 +1134,35 @@ class WorkflowPlugin extends Plugin {
    * 重载工作流
    */
   reload(framework) {
-    // 清除当前模块缓存，确保重新加载最新代码
-    delete require.cache[__filename];
+    // 清除所有 workflow 相关模块的 require 缓存（action.js / engine.js / json-runner.js / context.js）
+    // 否则即使代码已修改，Node.js 仍会使用旧的模块引用
+    const workflowDir = path.dirname(__filename);
+    // framework 根目录（用于清除 src/utils 等跨插件共享模块）
+    const frameworkRoot = path.resolve(workflowDir, '..', '..', '..');
+    const modulesToClear = [
+      __filename,
+      path.join(workflowDir, 'engine.js'),
+      path.join(workflowDir, 'json-runner.js'),
+      path.join(workflowDir, 'js-runner.js'),
+      path.join(workflowDir, 'context.js'),
+      path.join(workflowDir, 'stages', 'action.js'),
+      path.join(workflowDir, 'stages', 'choice.js'),
+      path.join(workflowDir, 'stages', 'each.js'),
+      path.join(workflowDir, 'stages', 'parallel.js'),
+      path.join(frameworkRoot, 'src', 'utils', 'sandbox.js'),
+    ];
+    for (const modPath of modulesToClear) {
+      delete require.cache[modPath];
+    }
+
+    // 销毁 v2 引擎实例（懒加载缓存），强制下次执行时重建
+    this._flowEngineV2 = null;
+
     this._framework = framework;
     const fresh = require(__filename);
+    // 重现现有实例的 prototype，让后续方法调用走最新代码
+    // (实例属性如 _workflows/_workflowTools/_engine 保持，prototype 方法切换为 fresh)
+    Object.setPrototypeOf(this, fresh.WorkflowPlugin.prototype);
     // 重新创建 engine（确保使用最新代码）
     this._engine = new fresh.WorkflowEngine(framework);
     // 注册内置步骤类型
@@ -1087,8 +1177,12 @@ class WorkflowPlugin extends Plugin {
     this._engine.registerStepType(fresh.StepType.DELAY, fresh.DelayStep);
     this._engine.registerStepType(fresh.StepType.WORKFLOW, fresh.NestedWorkflowStep);
     // 清除已注册的工具
+    // framework.registerTool/unregisterTool 会同步重置 ChatHandler._aiToolsCache。
     for (const toolName of this._workflowTools.values()) {
-      // 工具注销需要框架支持，这里只清理内部状态
+      try {
+        if (this._framework?.unregisterTool) this._framework.unregisterTool(toolName);
+        else this._framework?.toolRegistry?.unregister?.(toolName);
+      } catch (_) {}
     }
     this._workflowTools.clear();
     this._workflows.clear();
@@ -1104,8 +1198,15 @@ class WorkflowPlugin extends Plugin {
   }
   /**
    * 执行工作流
+   * 支持 v2 JSON 和 JS 格式
    */
   async executeWorkflow(workflowDef, input = {}, sessionId = null) {
+    // Lazy load v2 engine to avoid circular require
+    if (!this._flowEngineV2) {
+      const { FlowEngine } = require('./engine');
+      this._flowEngineV2 = new FlowEngine(this._framework);
+    }
+
     try {
       let workflow;
       if (typeof workflowDef === 'string') {
@@ -1114,55 +1215,20 @@ class WorkflowPlugin extends Plugin {
         if (this._workflows.has(workflowName)) {
           workflow = this._workflows.get(workflowName);
         } else {
-          // 尝试解析 JSON 或执行代码
+          // 尝试解析 JSON
           try {
             workflow = JSON.parse(workflowDef);
           } catch {
-            // 使用沙箱解析工作流定义，防止恶意代码执行
-            workflow = runWorkflowSafely(workflowDef, this._engine, { timeout: 5000 });
+            // JSON 解析失败，视为 JS 代码
+            workflow = workflowDef;
           }
         }
       } else {
         workflow = workflowDef;
       }
-      const context = this._engine.createContext(input, {});
-      // 将 sessionId 存储到上下文变量，供工具步骤使用
-      if (sessionId) {
-        context.variables._sessionId = sessionId;
-      }
-      // 执行工作流步骤
-      if (workflow.steps && Array.isArray(workflow.steps)) {
-        const results = [];
-        // 按 id 存储步骤输出，供 ${id.output} 引用
-        context.variables._stepOutputs = {};
-        for (const stepConfig of workflow.steps) {
-          const step = this._engine.createStep(stepConfig);
-          const result = await step.execute(context, this._engine);
-          results.push(result);
-          // 如果步骤有 id，存储其输出
-          if (stepConfig.id) {
-            context.variables._stepOutputs[stepConfig.id] = result;
-          }
-        }
-        // 只返回最后一步的结果（包含最终输出）和成功状态
-        // 不返回所有中间结果，避免上下文超限
-        const lastResult = results.length > 0 ? results[results.length - 1] : null;
-        // 从 context.variables 中提取非下划线开头的用户变量
-        // 下划线开头的是内部变量（如 _stepOutputs），不需要返回
-        const userVariables = {};
-        for (const [key, value] of Object.entries(context.variables)) {
-          if (!key.startsWith('_')) {
-            userVariables[key] = value;
-          }
-        }
-        return {
-          success: true,
-          stepCount: workflow.steps.length,
-          result: lastResult,
-          output: userVariables,
-        };
-      }
-      return { success: true, output: {} };
+
+      // 委托给 v2 引擎执行
+      return await this._flowEngineV2.execute(workflow, input, sessionId);
     } catch (err) {
       return { success: false, error: err.message };
     }

package/plugins/core/workflow/js-runner.js

@@ -0,0 +1,318 @@
+/**
+ * JS Workflow Runner - Total.js Style (Secondary)
+ * Executes workflows defined in JavaScript format using $.push(), $.next(), $.send() API
+ */
+
+const { runScriptSafely } = require('../../../src/utils/sandbox');
+
+class JsRunner {
+  constructor(framework) {
+    this.framework = framework;
+    this._log = require('../../../src/common/logger').logger.child('JsRunner');
+  }
+
+  /**
+   * Execute a JS workflow
+   * @param {string|Function} workflowCode - Workflow code or exported function
+   * @param {Object} input - Input data
+   * @param {string} sessionId - Session ID for tool execution
+   * @returns {Promise<Object>} execution result
+   */
+  async execute(workflowCode, input = {}, sessionId = null) {
+    this._log.debug('Executing JS workflow');
+
+    const { FlowContext } = require('./context');
+    const context = new FlowContext(input, sessionId);
+    context.setFramework(this.framework);
+
+    // Create stage executor and attach to context
+    const stageExecutor = new JsStageExecutor(this.framework);
+    context._stageExecutor = stageExecutor;
+
+    try {
+      // Get the workflow function
+      let workflowFn;
+      if (typeof workflowCode === 'function') {
+        workflowFn = workflowCode;
+      } else if (typeof workflowCode === 'string') {
+        workflowFn = this._parseWorkflow(workflowCode);
+      } else {
+        throw new Error('Workflow must be a function or string');
+      }
+
+      // Create the $ object for Total.js style API
+      const $ = this._createFlowApi(context, stageExecutor);
+
+      // Execute the workflow function
+      const flowPromise = workflowFn($);
+
+      // If it returns a promise, wait for it
+      if (flowPromise && typeof flowPromise.then === 'function') {
+        await flowPromise;
+      }
+
+      // Execute stages until destroyed or no more pending next
+      await this._runStages(context, stageExecutor);
+
+      // Build output
+      const output = {};
+      for (const [key, value] of context._results) {
+        output[key] = value;
+      }
+
+      return {
+        success: !context._destroyed,
+        output,
+        result: context._sentData || output,
+      };
+    } catch (err) {
+      this._log.error(`JS Workflow execution error: ${err.message}`);
+      return {
+        success: false,
+        error: err.message,
+      };
+    }
+  }
+
+  /**
+   * Parse workflow code string into a function
+   * Supports:
+   *   FLOW(function($) { ... })  - Direct function
+   *   module.exports = function($) { ... }  - CommonJS export
+   *   module.exports.default = function($) { ... }  - Default export
+   */
+  _parseWorkflow(code) {
+    const sandboxContext = {
+      console: { log() {}, error() {}, warn() {}, info() {} },
+      Math,
+      JSON,
+      Promise,
+      Array,
+      Object,
+      Date,
+      RegExp,
+      Error,
+      Symbol,
+      Map,
+      Set,
+      module: { exports: {} },
+      exports: {},
+      FlowContext: require('./context').FlowContext,
+    };
+
+    try {
+      const ctx = require('vm').createContext(sandboxContext);
+
+      // Check which format the code uses
+      const isModuleExport = code.includes('module.exports');
+      let fn;
+
+      if (isModuleExport) {
+        // CommonJS export format: module.exports = function($) { ... }
+        const wrapped = `
+          (function(module, exports, FlowContext) {
+            ${code}
+            return module.exports;
+          })
+        `;
+        const factory = require('vm').runInContext(wrapped, ctx, { timeout: 5000 });
+        fn = factory(ctx.module, ctx.exports, require('./context').FlowContext);
+      } else if (code.includes('FLOW(')) {
+        // FLOW wrapper format: FLOW(function($) { ... })
+        const wrapped = `(function(FlowContext) { return (${code}) })`;
+        fn = require('vm').runInContext(wrapped, ctx, { timeout: 5000 });
+        fn = fn(require('./context').FlowContext);
+      } else {
+        // Assume it's a function directly
+        const wrapped = `(function(FlowContext) { return (${code}) })`;
+        fn = require('vm').runInContext(wrapped, ctx, { timeout: 5000 });
+        fn = fn(require('./context').FlowContext);
+      }
+
+      // Handle module.exports.default
+      if (fn && fn.default) {
+        fn = fn.default;
+      }
+
+      return fn;
+    } catch (err) {
+      throw new Error(`Failed to parse workflow: ${err.message}`);
+    }
+  }
+
+  /**
+   * Create the $ API object for Total.js style
+   */
+  _createFlowApi(context, stageExecutor) {
+    const $ = {
+      // Register a stage
+      push: (name, fn) => {
+        context.push(name, fn);
+        return $;
+      },
+
+      // Go to next stage (sync) - 支持直接传参
+      next: (name, ...args) => {
+        context.next(name, ...args);
+        return $;
+      },
+
+      // Go to next stage (async helper)
+      next2: (name, ...args) => {
+        return () => {
+          context.next(name, ...args);
+        };
+      },
+
+      // Send data to next stage
+      send: (data) => {
+        context.send(data);
+        return $;
+      },
+
+      // Input from previous stage (返回 sentData �?workflow input)
+      get input() {
+        return context._sentData !== undefined ? context._sentData : context.input;
+      },
+
+      // Flow-level persistent data
+      data: context.data,
+
+      // Built-in delay
+      wait: (ms) => context.wait(ms),
+
+      // $.tool - Tool accessor with list(), execute(), register(), get()
+      get tool() { return context.tool; },
+
+      // $.extension - Extension accessor with list(), register(), remove(), execute(), get()
+      get extension() { return context.extension; },
+
+      // $.workflow - Workflow accessor with list(), execute(), get()
+      get workflow() { return context.workflow; },
+
+      // $.agent - Agent accessor with create(), chat(), list()
+      get agent() { return context.agent; },
+
+      // $.prompt - Prompt accessor with send(), chat()
+      get prompt() { return context.prompt; },
+
+      // $.skill - Skill accessor with list(), execute(), get()
+      get skill() { return context.skill; },
+
+      // Execute script
+      script: (code) => context.script(code),
+
+      // End workflow
+      destroy: () => context.destroy(),
+
+      // Current stage info
+      get current() { return context.current; },
+      get prev() { return context.prev; },
+
+      // Stage registry
+      _stages: context._stages,
+    };
+
+    return $;
+  }
+
+  /**
+   * Run stages sequentially based on $.next() calls
+   */
+  async _runStages(context, stageExecutor) {
+    // Create $ API object for this run
+    const $ = this._createFlowApi(context, stageExecutor);
+
+    while (!context._destroyed && context._pendingNext) {
+      const nextName = context._pendingNext;
+
+      // Get args that were passed via $.next(name, ...args)
+      const args = context._sentData;
+      context._sentData = null;
+      context._pendingNext = null;
+
+      const fn = context._stages?.get(nextName);
+      if (!fn) {
+        this._log.warn(`Stage "${nextName}" not found`);
+        break;
+      }
+
+      context.prev = context.current;
+      context.current = nextName;
+
+      this._log.debug(`Executing JS stage: ${nextName}`);
+
+      try {
+        // Call fn with $ as first arg, then unpack args
+        // Supports: fn($) or fn($, a, b, c)
+        const fnArgs = args !== undefined
+          ? (Array.isArray(args) ? [$, ...args] : [$, args])
+          : [$];
+
+        const result = fn(...fnArgs);
+        if (result && typeof result.then === 'function') {
+          await result;
+        }
+      } catch (err) {
+        this._log.error(`Stage "${nextName}" error: ${err.message}`);
+        context.destroy();
+        throw err;
+      }
+    }
+  }
+}
+
+/**
+ * JS Stage Executor - handles stage execution in JS workflows
+ */
+class JsStageExecutor {
+  constructor(framework) {
+    this.framework = framework;
+    this._log = require('../../../src/common/logger').logger.child('JsStageExecutor');
+  }
+
+  /**
+   * Execute a stage from JSON config within a JS workflow
+   */
+  async executeStage(config, context) {
+    const { ActionStage } = require('./stages/action');
+    const { ChoiceStage } = require('./stages/choice');
+    const { EachStage } = require('./stages/each');
+    const { ParallelStage } = require('./stages/parallel');
+    const type = this._getStageType(config);
+
+    switch (type) {
+      case 'action': {
+        const stage = new ActionStage(config);
+        return await stage.execute(context);
+      }
+      case 'choice': {
+        const stage = new ChoiceStage(config);
+        const nextStage = await stage.execute(context);
+        if (nextStage) {
+          context._pendingNext = nextStage;
+        }
+        return { nextStage };
+      }
+      case 'each': {
+        const stage = new EachStage(config);
+        return await stage.execute(context);
+      }
+      case 'parallel': {
+        const stage = new ParallelStage(config);
+        return await stage.execute(context);
+      }
+      default:
+        throw new Error(`Unknown stage type: ${type}`);
+    }
+  }
+
+  _getStageType(config) {
+    if (config.choice || config.when || config.default) return 'choice';
+    if (config.each || config.over) return 'each';
+    if (config.parallel) return 'parallel';
+    return 'action';
+  }
+}
+
+module.exports = { JsRunner };