foliko 2.0.5 → 2.0.7

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

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

@@ -0,0 +1,123 @@
+/**
+ * each stage executor
+ * Loop over items
+ */
+
+class EachStage {
+  constructor(config) {
+    this.name = config.name;
+    this.each = config.each; // Array to iterate over
+    this.as = config.as || 'item'; // Item variable name
+    this.index = config.index || 'index'; // Index variable name
+    this.stages = config.stages || []; // Child stages to execute for each item
+    this.maxIterations = config.maxIterations || 100;
+    this.until = config.until; // Early exit condition
+    this._log = require('../../../../src/common/logger').logger.child('EachStage');
+  }
+
+  /**
+   * Execute the each stage
+   * @param {FlowContext} context
+   * @returns {Promise<Array>} results for each iteration
+   */
+  async execute(context) {
+    this._log.debug(`Executing each loop: ${this.name}`);
+
+    // Resolve the array to iterate
+    let array;
+    if (typeof this.each === 'string') {
+      // Strip optional surrounding {{ }} so users can write either
+      //   "each": "items"          (bare identifier)
+      //   "each": "{{items}}"       (templated)
+      //   "each": "{{init.items}}"  (stage.field)
+      let path = this.each.trim();
+      const m = path.match(/^\{\{([^}]+)\}\}$/);
+      if (m) path = m[1].trim();
+
+      // Use the low-level _resolvePath so we get the actual array/object back
+      // (String.prototype.replace in resolveValue would coerce non-strings.)
+      let resolved = context._resolvePath(path);
+      if (resolved === undefined && path.startsWith('[')) {
+        // Support inline array literal: each: "['a','b']"
+        try { resolved = JSON.parse(path); } catch {}
+      }
+      if (Array.isArray(resolved)) {
+        array = resolved;
+      } else if (resolved && typeof resolved === 'object') {
+        // Convert object to entries (so {{k, v}} style iteration works)
+        array = Object.entries(resolved);
+      } else {
+        throw new Error(`each "${this.each}" resolved to non-iterable: ${typeof resolved}`);
+      }
+    } else if (Array.isArray(this.each)) {
+      array = this.each;
+    } else {
+      throw new Error(`each stage "${this.name}" requires an array to iterate`);
+    }
+
+    const results = [];
+    const maxIter = Math.min(this.maxIterations, array.length);
+
+    for (let i = 0; i < maxIter; i++) {
+      // Set loop variables
+      context.data[this.as] = array[i];
+      context.data[this.index] = i;
+      context.data.loopIndex = i; // Legacy alias
+
+      this._log.debug(`Each iteration ${i}: ${this.as}=`, array[i]);
+
+      // Execute child stages sequentially
+      let stageResults = [];
+      for (const stageConfig of this.stages) {
+        const stageExecutor = context._stageExecutor;
+        if (stageExecutor) {
+          const result = await stageExecutor.executeStage(stageConfig, context);
+          stageResults.push(result);
+
+          // Check for early exit
+          if (context._destroyed) {
+            this._log.debug('Flow destroyed, stopping each loop');
+            break;
+          }
+        }
+      }
+      results.push(stageResults);
+
+      // Check until condition
+      if (this.until) {
+        try {
+          const { evaluateInSandbox } = require('../../../../../src/utils/sandbox');
+          const evalContext = {
+            input: context.input,
+            data: context.data,
+            variables: Object.fromEntries(context._results),
+            previousResult: context._sentData,
+            item: array[i],
+            index: i,
+          };
+          const shouldStop = evaluateInSandbox(this.until, evalContext, { timeout: 5000 });
+          if (shouldStop) {
+            this._log.debug(`Each loop terminated at iteration ${i} by until condition`);
+            break;
+          }
+        } catch (err) {
+          this._log.warn(`until condition error: ${err.message}`);
+        }
+      }
+    }
+
+    // Cleanup loop variables
+    delete context.data[this.as];
+    delete context.data[this.index];
+    delete context.data.loopIndex;
+
+    // Store results by name if this stage has a name
+    if (this.name) {
+      context.setResult(this.name, results);
+    }
+
+    return results;
+  }
+}
+
+module.exports = { EachStage };

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

@@ -0,0 +1,69 @@
+/**
+ * parallel stage executor
+ * Run stages concurrently
+ */
+
+class ParallelStage {
+  constructor(config) {
+    this.name = config.name;
+    this.parallel = config.parallel || []; // Array of stages to run in parallel
+    this._log = require('../../../../src/common/logger').logger.child('ParallelStage');
+  }
+
+  /**
+   * Execute the parallel stage
+   * @param {FlowContext} context
+   * @returns {Promise<Array>} results from all parallel stages
+   */
+  async execute(context) {
+    this._log.debug(`Executing parallel: ${this.name}`);
+
+    if (!this.parallel || this.parallel.length === 0) {
+      return [];
+    }
+
+    const stageExecutor = context._stageExecutor;
+    if (!stageExecutor) {
+      throw new Error('Stage executor not set in context');
+    }
+
+    // Execute all stages concurrently
+    const promises = this.parallel.map(async (stageConfig) => {
+      try {
+        return await stageExecutor.executeStage(stageConfig, context);
+      } catch (err) {
+        this._log.warn(`Parallel stage error: ${err.message}`);
+        return { error: err.message };
+      }
+    });
+
+    const results = await Promise.all(promises);
+
+    // Build result object keyed by stage name (not plain array)
+    const resultByName = {};
+    for (let i = 0; i < this.parallel.length; i++) {
+      const stageConfig = this.parallel[i];
+      const name = stageConfig.name || String(i);
+      resultByName[name] = results[i];
+    }
+
+    // Store named results in context
+    // If the parallel block itself has a name, store the keyed object
+    if (this.name) {
+      context.setResult(this.name, resultByName);
+    }
+
+    // Also store individual named results for access via {{stageName}}
+    for (let i = 0; i < this.parallel.length; i++) {
+      const stageConfig = this.parallel[i];
+      if (stageConfig.name) {
+        context.setResult(stageConfig.name, results[i]);
+      }
+    }
+
+    this._log.debug(`Parallel completed: ${results.length} stages`);
+    return resultByName;
+  }
+}
+
+module.exports = { ParallelStage };

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

@@ -0,0 +1,142 @@
+/**
+ * try stage executor
+ *
+ * Wraps a sequence of child stages in a try/catch so a single failure
+ * doesn't tear down the entire workflow. Optional `finally` stages run
+ * regardless of outcome.
+ *
+ * Configuration:
+ *   {
+ *     "name": "safe-fetch",       // optional, allows {{safe-fetch.success}} access
+ *     "try": {
+ *       "stages": [ ... ]         // required
+ *     },
+ *     "catch": {                  // optional
+ *       "stages": [ ... ],
+ *       "as": "err"               // optional name to inject error.message into context.data
+ *     },
+ *     "finally": {                // optional
+ *       "stages": [ ... ]
+ *     }
+ *   }
+ *
+ * Result shape (stored on the named stage and returned):
+ *   {
+ *     success: true | false,
+ *     result: <last try stage output>,        // when success=true
+ *     error: "<message>",                       // when success=false (optional stack)
+ *     caught: [ ...catch stage results... ],   // when catch ran
+ *     finally: [ ...finally stage results... ] // when finally ran
+ *   }
+ */
+
+class TryStage {
+  constructor(config) {
+    this.name = config.name;
+    this.tryConfig = config.try || { stages: [] };
+    this.catchConfig = config.catch || null;
+    this.finallyConfig = config.finally || null;
+    this._log = require('../../../../src/common/logger').logger.child('TryStage');
+  }
+
+  /**
+   * Execute a list of sub-stages using the shared StageExecutor.
+   * Wraps each individual stage in its own try/catch so a single stage failure
+   * doesn't break the chain unless it's the top-level try.
+   */
+  async _runStages(stages, context, { stopOnError = false } = {}) {
+    if (!stages || !Array.isArray(stages) || stages.length === 0) return [];
+    const stageExecutor = context._stageExecutor;
+    if (!stageExecutor) {
+      throw new Error('Stage executor not set in context');
+    }
+
+    const out = [];
+    for (const stage of stages) {
+      try {
+        const result = await stageExecutor.executeStage(stage, context);
+        out.push(result);
+        if (context._destroyed) break;
+      } catch (err) {
+        if (stopOnError) {
+          throw err;
+        }
+        this._log.warn(`Stage "${stage.name || '(unnamed)'}" failed inside try: ${err.message}`);
+        out.push({ error: err.message, stage: stage.name });
+      }
+    }
+    return out;
+  }
+
+  async execute(context) {
+    this._log.debug(`Executing try stage: ${this.name || '(unnamed)'}`);
+
+    let success = true;
+    let error = null;
+    let tryResult = null;
+    let caughtResult = null;
+    let finallyResult = null;
+
+    // === try block ===
+    try {
+      tryResult = await this._runStages(this.tryConfig.stages || [], context, { stopOnError: true });
+    } catch (err) {
+      success = false;
+      error = err;
+      this._log.debug(`Try block failed: ${err.message}`);
+
+      // === catch block ===
+      if (this.catchConfig) {
+        // Optionally expose the error under a chosen key in context.data
+        if (this.catchConfig.as) {
+          context.data[this.catchConfig.as] = err;
+        }
+        try {
+          caughtResult = await this._runStages(this.catchConfig.stages || [], context);
+        } catch (catchErr) {
+          this._log.warn(`catch block itself failed: ${catchErr.message}`);
+          caughtResult = [{ error: catchErr.message }];
+        }
+      }
+    }
+
+    // === finally block (always runs) ===
+    if (this.finallyConfig) {
+      try {
+        finallyResult = await this._runStages(this.finallyConfig.stages || [], context);
+      } catch (finallyErr) {
+        this._log.warn(`finally block failed: ${finallyErr.message}`);
+        finallyResult = [{ error: finallyErr.message }];
+      }
+    }
+
+    // Cleanup injected error reference so it doesn't leak past the try stage
+    if (this.catchConfig && this.catchConfig.as) {
+      delete context.data[this.catchConfig.as];
+    }
+
+    const output = success
+      ? {
+          success: true,
+          result: tryResult && tryResult.length > 0 ? tryResult[tryResult.length - 1] : null,
+          stages: tryResult,
+          finally: finallyResult,
+        }
+      : {
+          success: false,
+          error: error.message,
+          stack: error.stack,
+          caught: caughtResult,
+          stages: tryResult,
+          finally: finallyResult,
+        };
+
+    if (this.name) {
+      context.setResult(this.name, output);
+    }
+
+    return output;
+  }
+}
+
+module.exports = { TryStage };