foliko 2.0.22 → 2.0.23

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

@@ -1,323 +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 };
+/**
+ * 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 };