foliko 2.0.6 → 2.0.7

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

package/plugins/executors/data-splitter/index.js

@@ -7,6 +7,7 @@ const { Plugin } = require('../../../src/plugin/base');
 const { z } = require('zod');
 const { logger } = require('../../../src/common/logger');
 const { DataSplitter } = require('../../../src/utils/data-splitter');
+const { safeStringify } = require('../../../src/common/json-safe');
 
 const AUTO_SPLIT_THRESHOLD = 50000;
 const PROMPT_DIR = __dirname;
@@ -177,9 +178,9 @@ class DataSplitterPlugin extends Plugin {
 
       let checkContent = '';
       if (result && typeof result === 'object' && result.data) {
-        checkContent = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
+        checkContent = typeof result.data === 'string' ? result.data : safeStringify(result.data);
       } else {
-        checkContent = typeof result === 'string' ? result : JSON.stringify(result);
+        checkContent = typeof result === 'string' ? result : safeStringify(result);
       }
       if (!checkContent || checkContent.length < this.config.autoSplitThreshold) return;
     };

package/sandbox/check-context.js

@@ -0,0 +1,5 @@
+const fs = require('fs');
+const path = require('path');
+const src = fs.readFileSync('plugins/core/workflow/context.js', 'utf8');
+console.log('async tool(name, args) present?', src.includes('async tool(name, args)'));
+console.log('get tool() present?', src.includes('get tool()'));

package/sandbox/test-context.js

@@ -0,0 +1,27 @@
+const { FlowContext } = require('../plugins/core/workflow/context');
+const c = new FlowContext({}, 'sid');
+const proto = Object.getPrototypeOf(c);
+console.log('tool:', typeof c.tool, c.tool.name);
+console.log('_executeTool on instance:', typeof c._executeTool);
+console.log('_executeTool on proto:', typeof proto._executeTool);
+console.log('proto tool-related keys:', Object.getOwnPropertyNames(proto).filter(n => n.includes('tool')));
+console.log('proto _-prefixed keys:', Object.getOwnPropertyNames(proto).filter(n => n.startsWith('_')));
+
+// Try calling tool
+c.setFramework({ executeTool: async () => ({ success: true }) });
+(async () => {
+  try {
+    const r = await c.tool('foo', {});
+    console.log('tool() result:', r);
+  } catch (e) {
+    console.log('tool() error:', e.message);
+  }
+  // What if we assign _executeTool directly?
+  console.log('--- now direct _executeTool call ---');
+  try {
+    const r2 = await c._executeTool('foo', {});
+    console.log('_executeTool() result:', r2);
+  } catch (e2) {
+    console.log('_executeTool() error:', e2.message);
+  }
+})();

package/sandbox/test-fixes.js

@@ -0,0 +1,40 @@
+const fs = require('fs');
+const path = require('path');
+
+const helloPath = path.resolve('.foliko/workflows/hello-js.js');
+delete require.cache[helloPath];
+const helloModule = require(helloPath);
+
+const t = typeof helloModule;
+console.log('hello-js.js type:', t);
+
+if (t === 'function') {
+  try {
+    const wf = helloModule({});
+    console.log('returned keys:', Object.keys(wf));
+    console.log(
+      'steps count:',
+      Array.isArray(wf.steps) ? wf.steps.length : 'N/A'
+    );
+    console.log('OK: js workflow shape is v2 compatible');
+  } catch (e) {
+    console.log('execution failed (expected):', e.message);
+  }
+}
+
+// Also verify the manager.js and workflow/index.js parse OK
+const filesToCheck = [
+  'src/plugin/manager.js',
+  'plugins/core/workflow/index.js',
+];
+
+for (const rel of filesToCheck) {
+  const p = path.resolve(rel);
+  delete require.cache[p];
+  try {
+    const m = require(p);
+    console.log(`OK ${rel}: parsed, exports=`, Object.keys(m).slice(0, 5));
+  } catch (e) {
+    console.log(`FAIL ${rel}:`, e.message);
+  }
+}

package/sandbox/test-hello-js.js

@@ -0,0 +1,46 @@
+(async () => {
+  try {
+    const { JsRunner } = require('../plugins/core/workflow/js-runner');
+    const stubFramework = {
+      executeTool: async (name, args, sid) => {
+        console.log('  [tool]', name, JSON.stringify(args));
+        return { success: true, data: 'tool_ok', echo: args };
+      },
+      runWithContext: async (ctx, fn) => fn(),
+      getExecutionContext: () => ({ sessionId: 'test-session' })
+    };
+    // Override the proxy used by JsRunner to bind tool/extension/etc.
+    // (see fix in _createFlowApi below)
+    const origRequire = require.cache[require.resolve('../plugins/core/workflow/js-runner.js')].exports;
+    console.log('JsRunner exports:', Object.keys(origRequire));
+    console.log('tool keys at runtime:');
+    const { FlowContext } = require('../plugins/core/workflow/context');
+    const c = new FlowContext({}, 'sid');
+    c.setFramework(stubFramework);
+    const t = c.tool;
+    console.log(' t:', t);
+    console.log(' Object.getOwnPropertyNames:', Object.getOwnPropertyNames(t));
+    console.log(' for-in:');
+    for (const k in t) { console.log('   -', k); }
+    console.log(' execute type:', typeof t.execute);
+    const r = new JsRunner(stubFramework);
+    const wfPath = require.resolve('../.foliko/workflows/hello-js.js');
+    delete require.cache[wfPath];
+    const wf = require(wfPath);
+    const res = await r.execute(wf, {}, 'test-session');
+    console.log('Result:', JSON.stringify(res, null, 2));
+
+    // Direct test of $.tool
+    console.log('Direct $.tool test...');
+    const $obj = { data: {}, get tool() { return c.tool; }, push: () => {}, next: () => {} };
+    try {
+      const out = await $.tool.execute('notification_send', { title: 'x', message: 'y' });
+      console.log('Direct $.tool result:', out);
+    } catch (e) {
+      console.log('Direct $.tool error:', e.message);
+    }
+  } catch (err) {
+    console.error('OUTER ERROR:', err && err.stack || err);
+    process.exit(1);
+  }
+})();