foliko 2.0.5 → 2.0.7

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 };

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

@@ -0,0 +1,323 @@
+/**
+ * JSON Workflow Runner - Primary v2 format
+ * Executes workflows defined in JSON format
+ */
+
+const { ActionStage } = require('./stages/action');
+const { ChoiceStage } = require('./stages/choice');
+const { EachStage } = require('./stages/each');
+const { ParallelStage } = require('./stages/parallel');
+const { TryStage } = require('./stages/try');
+const { DelayStage } = require('./stages/delay');
+const { evaluateInSandbox } = require('../../../src/utils/sandbox');
+
+class JsonRunner {
+  constructor(framework) {
+    this.framework = framework;
+    this._log = require('../../../src/common/logger').logger.child('JsonRunner');
+  }
+
+  /**
+   * Execute a JSON workflow
+   * @param {Object} workflow - Workflow definition with flow, version, stages
+   * @param {Object} input - Input data
+   * @param {string} sessionId - Session ID for tool execution
+   * @returns {Promise<Object>} execution result
+   */
+  async execute(workflow, input = {}, sessionId = null) {
+    this._log.debug(`Executing JSON workflow: ${workflow.flow || 'unnamed'}`);
+
+    const { FlowContext } = require('./context');
+    const context = new FlowContext(input, sessionId);
+    context.setFramework(this.framework);
+
+    // Create stage executor and attach to context
+    const stageExecutor = new StageExecutor(this.framework);
+    context._stageExecutor = stageExecutor;
+
+    try {
+      // Execute stages sequentially
+      let stageIndex = 0;
+      const stages = workflow.stages || [];
+
+      // Track choice context for branch skipping
+      // When a choice selects a branch, we identify all sibling stages and skip non-selected ones
+      let choiceContext = null; // { choiceIndex, branches[], skipStageNames[] }
+
+      while (stageIndex < stages.length && !context._destroyed) {
+        const stageConfig = stages[stageIndex];
+        context.prev = context.current;
+        context.current = stageConfig.name || `stage_${stageIndex}`;
+
+        // Check if this stage should be skipped (it's a non-selected sibling of a choice)
+        // A "sibling" here means: any stage at the top level of `stages` whose name
+        // matches one of the choice's branch targets (do) or the default.
+        //
+        // Lifecycle:
+        //   1. Choice sets choiceContext = { targetStageName, skipBranchNames, choiceIndex,
+        //                                  targetExecuted=false } and jumps to the chosen branch.
+        //   2. While inside the branch's stage range: skip any stage whose name is in
+        //      skipBranchNames (siblings), then mark targetExecuted when the chosen
+        //      branch's own stage runs.
+        //   3. Once we've consumed a full stage past the target (i.e. we're leaving
+        //      the branch's "slot"), clear context so later choices/stages behave
+        //      normally.
+        if (choiceContext) {
+          const stageName = stageConfig.name;
+          if (choiceContext.skipBranchNames.includes(stageName)) {
+            this._log.debug(`Skipping branch "${stageName}" (not selected by choice at index ${choiceContext.choiceIndex})`);
+            stageIndex++;
+            continue;
+          }
+          if (choiceContext.targetExecuted) {
+            // The chosen branch has already run; any further sibling stage means
+            // we're moving past the choice group - clear the context.
+            choiceContext = null;
+          } else {
+            // This is the chosen branch's stage (or some other non-sibling stage
+            // before the target — treat as target).
+            if (stageName === choiceContext.targetStageName) {
+              choiceContext.targetExecuted = true;
+              this._log.debug(`Choice branch "${stageName}" is now executing`);
+            } else {
+              // Defensive: if something doesn't match the expected target, clear
+              // the context rather than risk skipping real work.
+              choiceContext = null;
+            }
+          }
+        }
+
+        this._log.debug(`Executing stage: ${context.current}`);
+
+        // Execute the stage
+        const result = await stageExecutor.executeStage(stageConfig, context);
+
+        // Check if stage set a pending next (for choice/each stages)
+        if (context._pendingNext) {
+          const nextStageName = context._pendingNext;
+          context._pendingNext = null;
+
+          // Find the next stage index by name
+          const nextIndex = stages.findIndex(
+            (s) => (s.name || `stage_${stages.indexOf(s)}`) === nextStageName
+          );
+          if (nextIndex >= 0) {
+            // Check if this jump is from a choice to one of its branches
+            const currentStage = stages[stageIndex];
+            if (currentStage && (currentStage.choice || currentStage.when)) {
+              // Collect ALL branch names (do targets) and default - these are all siblings
+              const allBranchNames = [];
+              if (currentStage.default) allBranchNames.push(currentStage.default);
+              for (const b of currentStage.choice || []) {
+                if (b.do) allBranchNames.push(b.do);
+              }
+              // Skip all branches except the selected one
+              const skipBranchNames = allBranchNames.filter(name => name !== nextStageName);
+              if (skipBranchNames.length > 0) {
+                choiceContext = {
+                  choiceIndex: stageIndex,
+                  targetStageName: nextStageName,
+                  skipBranchNames,
+                  targetExecuted: false,
+                };
+                this._log.debug(`Choice selected "${nextStageName}", skipping branches: ${skipBranchNames.join(', ')}`);
+              }
+            }
+
+            stageIndex = nextIndex;
+            continue;
+          } else {
+            this._log.warn(`Next stage "${nextStageName}" not found`);
+          }
+        }
+
+        stageIndex++;
+      }
+
+      // Build output from all stage results
+      const output = {};
+      for (const [key, value] of context._results) {
+        output[key] = value;
+      }
+
+      return {
+        success: true,
+        flow: workflow.flow,
+        stageCount: stages.length,
+        output,
+        result: context._sentData || output,
+      };
+    } catch (err) {
+      this._log.error(`Workflow execution error: ${err.message}`);
+      return {
+        success: false,
+        error: err.message,
+        flow: workflow.flow,
+      };
+    }
+  }
+}
+
+/**
+ * Stage Executor - executes individual stages based on type
+ */
+class StageExecutor {
+  constructor(framework) {
+    this.framework = framework;
+    this._log = require('../../../src/common/logger').logger.child('StageExecutor');
+  }
+
+  /**
+   * Execute a single stage
+   * @param {Object} config - Stage configuration
+   * @param {FlowContext} context - Flow context
+   * @returns {Promise<any>} stage result
+   */
+  async executeStage(config, context) {
+    const type = this._getStageType(config);
+
+    switch (type) {
+      case 'action':
+        return await this._executeAction(config, context);
+      case 'choice':
+        return await this._executeChoice(config, context);
+      case 'each':
+        return await this._executeEach(config, context);
+      case 'parallel':
+        return await this._executeParallel(config, context);
+      case 'try':
+        return await this._executeTry(config, context);
+      case 'delay':
+        return await this._executeDelay(config, context);
+      case 'stage':
+        return await this._executeNested(config, context);
+      default:
+        // Default to action (tool or script)
+        return await this._executeAction(config, context);
+    }
+  }
+
+  /**
+   * Determine stage type from configuration
+   */
+  _getStageType(config) {
+    if (config.try && typeof config.try === 'object') return 'try';
+    if (config.delay !== undefined || config.wait !== undefined) return 'delay';
+    if (config.choice || config.when || config.default) return 'choice';
+    if (config.each || config.over) return 'each';
+    if (config.parallel) return 'parallel';
+    if (config.stage) return 'stage';
+    if (config.tool || config.action || config.script) return 'action';
+    return 'action'; // Default
+  }
+
+  /**
+   * Execute action stage
+   */
+  async _executeAction(config, context) {
+    const stage = new ActionStage(config);
+    return await stage.execute(context);
+  }
+
+  /**
+   * Execute choice stage - may set context._pendingNext
+   */
+  async _executeChoice(config, context) {
+    const stage = new ChoiceStage(config);
+    const nextStage = await stage.execute(context);
+    if (nextStage) {
+      context._pendingNext = nextStage;
+    }
+    return { nextStage };
+  }
+
+  /**
+   * Execute each stage
+   */
+  async _executeEach(config, context) {
+    const stage = new EachStage(config);
+    return await stage.execute(context);
+  }
+
+  /**
+   * Execute parallel stage
+   */
+  async _executeParallel(config, context) {
+    const stage = new ParallelStage(config);
+    return await stage.execute(context);
+  }
+
+  /**
+   * Execute try-catch stage.
+   * Catches errors thrown by any child stage (action / script / tool) so a single
+   * failing stage doesn't tear down the whole workflow. Resolves with a
+   * `{ success, result | error, caught? }` object.
+   */
+  async _executeTry(config, context) {
+    const stage = new TryStage(config);
+    const result = await stage.execute(context);
+    if (config.name) {
+      context.setResult(config.name, result);
+    }
+    return result;
+  }
+
+  /**
+   * Execute delay/wait stage. Pure synchronous pause; the result is the
+   * resolved `data` payload (often `null`).
+   */
+  async _executeDelay(config, context) {
+    const stage = new DelayStage(config);
+    const result = await stage.execute(context);
+    if (config.name) {
+      context.setResult(config.name, result);
+    }
+    return result;
+  }
+
+  /**
+   * Execute nested stage (sub-workflow)
+   */
+  async _executeNested(config, context) {
+    if (!config.stage) {
+      throw new Error(`Nested stage "${config.name}" requires a stage definition`);
+    }
+
+    const { runScriptSafely } = require('../../../src/utils/sandbox');
+
+    // If stage is a script
+    if (typeof config.stage === 'string') {
+      // It's a reference to another stage or inline script
+      // For now, treat as inline script
+      const scriptContext = {
+        input: context.input,
+        data: context.data,
+        variables: Object.fromEntries(context._results),
+        previousResult: context._sentData,
+        console: { log: (...args) => this._log.debug('[Script]', ...args) },
+      };
+      return await runScriptSafely(config.stage, scriptContext, { timeout: 10000 });
+    }
+
+    // If stage is an object with stages array, execute sub-workflow
+    if (Array.isArray(config.stage.stages)) {
+      const subContext = new (require('./context').FlowContext)(context.input, context._sessionId);
+      subContext.setFramework(this.framework);
+      subContext._stageExecutor = this;
+
+      // Copy relevant data
+      subContext.data = { ...context.data };
+
+      for (const subStage of config.stage.stages) {
+        if (subContext._destroyed) break;
+        await this.executeStage(subStage, subContext);
+      }
+
+      return Object.fromEntries(subContext._results);
+    }
+
+    throw new Error(`Invalid nested stage definition for "${config.name}"`);
+  }
+}
+
+module.exports = { JsonRunner, StageExecutor };