foliko 2.0.6 → 2.0.8

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

package/plugins/core/workflow/stages/action.js

@@ -0,0 +1,211 @@
+/**
+ * action stage executor
+ * Executes a tool, script, or chain-style call (extension, skill, workflow, agent, prompt)
+ */
+
+const { runScriptSafely } = require('../../../../src/utils/sandbox');
+
+class ActionStage {
+  constructor(config) {
+    this.name = config.name;
+    this.tool = config.tool;
+    this.args = config.args || {};
+    this.script = config.script;
+    this.action = config.action; // alias for tool
+
+    // Chain-style call types for JSON format
+    this.extension = config.extension;  // extension name
+    this.skill = config.skill;        // skill name
+    this.workflow = config.workflow;  // workflow name
+    this.agent = config.agent;        // agent action
+    this.prompt = config.prompt;      // prompt action
+    this.command = config.command;    // command for skill
+  }
+
+  /**
+   * Execute the action stage
+   * @param {FlowContext} context
+   * @returns {Promise<any>} result
+   */
+  async execute(context) {
+    const log = context._log;
+
+    // Handle chain-style calls in JSON format
+    if (this.extension) {
+      return await this._executeExtension(context, log);
+    }
+    if (this.skill) {
+      return await this._executeSkill(context, log);
+    }
+    if (this.workflow) {
+      return await this._executeWorkflow(context, log);
+    }
+    if (this.agent) {
+      return await this._executeAgent(context, log);
+    }
+    if (this.prompt) {
+      return await this._executePrompt(context, log);
+    }
+
+    // Handle script execution first - "action": "script" with inline script code
+    if (this.script) {
+      log.debug(`Executing script in stage: ${this.name}`);
+
+      // 解析 script 模板字符串（支持 {{stageName}} 和 {{input.xxx}} 等）
+      const resolvedScript = context.resolveValue(this.script, { raw: true });
+      if (resolvedScript !== this.script) {
+        log.debug(`Script template resolved: ${this.script} -> ${resolvedScript}`);
+      }
+
+      // 暴露 $ 链式 API（与 JS 工作流格式保持一致）
+      const scriptContext = {
+        $: context,
+        input: context.input,
+        data: context.data,
+        variables: Object.fromEntries(context._results),
+        previousResult: context._sentData,
+        console: {
+          log: (...args) => {
+            log.debug('[Script]', ...args);
+          },
+        },
+      };
+
+      const result = await runScriptSafely(resolvedScript, scriptContext, { timeout: 10000 });
+
+      // Store result
+      if (this.name) {
+        context.setResult(this.name, result);
+      }
+
+      return result;
+    }
+
+    // Tool execution: if tool or action (non-"script") is specified
+    if (this.tool || (this.action && this.action !== 'script')) {
+      const toolName = this.tool || this.action;
+      log.debug(`Executing tool: ${toolName}`);
+
+      // Resolve args with variable interpolation
+      const resolvedArgs = context.resolveArgs(this.args);
+
+      // Execute tool
+      let result;
+      let sessionId = context._sessionId;
+      if (!sessionId && context._framework?.getExecutionContext) {
+        const ctx = context._framework.getExecutionContext();
+        sessionId = ctx?.sessionId;
+      }
+
+      if (sessionId && context._framework?.runWithContext) {
+        result = await context._framework.runWithContext(
+          { sessionId },
+          async () => await context._framework.executeTool(toolName, resolvedArgs)
+        );
+      } else {
+        result = await context._framework.executeTool(toolName, resolvedArgs);
+      }
+
+      // Store result
+      if (this.name) {
+        context.setResult(this.name, result);
+      }
+
+      return result;
+    }
+
+    throw new Error(`Action stage "${this.name}" has neither tool nor script`);
+  }
+
+  /**
+   * Execute extension call (JSON format: { extension: "name", tool: "toolName", args: {...} })
+   */
+  async _executeExtension(context, log) {
+    const toolName = this.tool || this.command;
+    if (!toolName) {
+      throw new Error(`Extension stage "${this.name}" requires a tool name`);
+    }
+
+    log.debug(`Executing extension: ${this.extension}/${toolName}`);
+    const result = await context.extension.execute(this.extension, toolName, this.args);
+
+    if (this.name) {
+      context.setResult(this.name, result);
+    }
+    return result;
+  }
+
+  /**
+   * Execute skill call (JSON format: { skill: "name", command: "cmd", args: {...} })
+   */
+  async _executeSkill(context, log) {
+    const command = this.command || this.tool;
+    if (!command) {
+      throw new Error(`Skill stage "${this.name}" requires a command`);
+    }
+
+    log.debug(`Executing skill: ${this.skill}/${command}`);
+    const result = await context.skill.execute(this.skill, command, this.args);
+
+    if (this.name) {
+      context.setResult(this.name, result);
+    }
+    return result;
+  }
+
+  /**
+   * Execute workflow call (JSON format: { workflow: "name", args: { input: {...} } })
+   */
+  async _executeWorkflow(context, log) {
+    log.debug(`Executing workflow: ${this.workflow}`);
+    const result = await context.workflow.execute(this.workflow, this.args.input || this.args);
+
+    if (this.name) {
+      context.setResult(this.name, result);
+    }
+    return result;
+  }
+
+  /**
+   * Execute agent call (JSON format: { agent: "action", args: {...} })
+   */
+  async _executeAgent(context, log) {
+    log.debug(`Executing agent: ${this.agent}`);
+    let result;
+
+    if (this.agent === 'create') {
+      const agent = await context.agent.create(this.args);
+      result = { success: true, agentId: agent.id };
+    } else if (this.agent === 'chat') {
+      result = await context.agent.chat(this.args);
+    } else {
+      throw new Error(`Unknown agent action: ${this.agent}`);
+    }
+
+    if (this.name) {
+      context.setResult(this.name, result);
+    }
+    return result;
+  }
+
+  /**
+   * Execute prompt call (JSON format: { prompt: "action", args: {...} })
+   */
+  async _executePrompt(context, log) {
+    log.debug(`Executing prompt: ${this.prompt}`);
+    let result;
+
+    if (this.prompt === 'send' || this.prompt === 'chat') {
+      result = await context.prompt.send(this.args);
+    } else {
+      throw new Error(`Unknown prompt action: ${this.prompt}`);
+    }
+
+    if (this.name) {
+      context.setResult(this.name, result);
+    }
+    return result;
+  }
+}
+
+module.exports = { ActionStage };

package/plugins/core/workflow/stages/choice.js

@@ -0,0 +1,74 @@
+/**
+ * choice stage executor
+ * Conditional branching (if/else/switch)
+ */
+
+const { evaluateInSandbox } = require('../../../../src/utils/sandbox');
+
+class ChoiceStage {
+  constructor(config) {
+    this.name = config.name;
+    this.choice = config.choice || []; // Array of { when, do } or { case, do }
+    this.default = config.default; // Default stage name
+    this._log = require('../../../../src/common/logger').logger.child('ChoiceStage');
+  }
+
+  /**
+   * Execute the choice stage
+   * @param {FlowContext} context
+   * @returns {Promise<string|null>} next stage name
+   */
+  async execute(context) {
+    this._log.debug(`Evaluating choice: ${this.name}`);
+
+    // Try each when/case condition
+    for (const branch of this.choice) {
+      const condition = branch.when || branch.case;
+      if (!condition) continue;
+
+      try {
+        // Resolve condition with variable interpolation
+        const resolvedCondition = context.resolveValue(condition);
+
+        // Evaluate condition
+        let matched = false;
+        if (typeof resolvedCondition === 'boolean') {
+          matched = resolvedCondition;
+        } else if (typeof resolvedCondition === 'string') {
+          // Use sandbox to evaluate the condition expression
+          // Extract stage results to top level so they can be accessed directly
+          // e.g., "init.value > 100" can access init from stage results
+          // Also spread context.data so each-loop variables (e.g. "fruit") work
+          // in choice conditions.
+          const stageResults = Object.fromEntries(context._results);
+          const evalContext = {
+            ...stageResults,  // Spread stage results to top level
+            ...context.data,  // Spread data so loop variables are reachable
+            input: context.input,
+            data: context.data,
+            previousResult: context._sentData,
+          };
+          matched = evaluateInSandbox(resolvedCondition, evalContext, { timeout: 5000 });
+        }
+
+        if (matched) {
+          this._log.debug(`Choice matched: ${condition} -> ${branch.do}`);
+          return branch.do; // Return next stage name
+        }
+      } catch (err) {
+        this._log.warn(`Condition evaluation error for "${condition}": ${err.message}`);
+      }
+    }
+
+    // No condition matched, use default
+    if (this.default) {
+      this._log.debug(`No choice matched, using default: ${this.default}`);
+      return this.default;
+    }
+
+    this._log.debug(`No choice matched and no default for: ${this.name}`);
+    return null;
+  }
+}
+
+module.exports = { ChoiceStage };

package/plugins/core/workflow/stages/delay.js

@@ -0,0 +1,73 @@
+/**
+ * delay stage executor
+ *
+ * Pauses the workflow for a given number of milliseconds.
+ *
+ * Configuration:
+ *   {
+ *     "name": "wait-step",      // optional
+ *     "ms": 1000,               // milliseconds to wait (alias: delay, wait)
+ *     "result": { ... }         // optional value to record as the stage's output
+ *   }
+ *
+ * Useful for rate-limiting, pacing retries, or signaling that an
+ * external dependency is allowed time to settle.
+ */
+
+class DelayStage {
+  constructor(config) {
+    this.name = config.name;
+    // Accept several common field names so declarative authoring stays ergonomic.
+    this.msRaw = config.ms ?? config.delay ?? config.wait ?? 0;
+    this.result = config.result; // optional value to surface as the stage output
+    this._log = require('../../../../src/common/logger').logger.child('DelayStage');
+  }
+
+  /**
+   * Get the resolved delay in ms.
+   * Supports string templates (e.g. "{{poll-interval}}") so the wait time
+   * can be derived from prior stage output.
+   */
+  _resolveMs(context) {
+    const resolveOptions = { raw: true };
+    if (typeof this.msRaw === 'string') {
+      const resolved = context.resolveValue(this.msRaw, resolveOptions);
+      const num = Number(resolved);
+      if (Number.isFinite(num) && num >= 0) {
+        return num;
+      }
+      return 0;
+    }
+    const num = Number(this.msRaw);
+    return Number.isFinite(num) && num >= 0 ? num : 0;
+  }
+
+  async execute(context) {
+    const ms = this._resolveMs(context);
+    this._log.debug(`Delay stage "${this.name || '(unnamed)'}" waiting ${ms}ms`);
+
+    // Hard cap: avoid accidental multi-hour sleeps via bad input.
+    const MAX_DELAY_MS = 10 * 60 * 1000; // 10 minutes
+    const safeMs = Math.min(ms, MAX_DELAY_MS);
+
+    await new Promise((resolve) => setTimeout(resolve, safeMs));
+
+    // Optional result payload (used when the stage is named and downstream
+    // stages need to reference the resolution time, e.g. "{{wait.done}}").
+    const payload = typeof this.result === 'string'
+      ? context.resolveValue(this.result, { raw: true })
+      : this.result;
+
+    const output = payload !== undefined
+      ? payload
+      : { waited: safeMs, completedAt: new Date().toISOString() };
+
+    if (this.name) {
+      context.setResult(this.name, output);
+    }
+
+    return output;
+  }
+}
+
+module.exports = { DelayStage };