@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/cli/flow-weaver-run-DSTLSTHR.mjs

@@ -0,0 +1,555 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  readJsonObjectOption
+} from "./flow-weaver-chunk-UNFS3NQP.mjs";
+import {
+  DebugController
+} from "./flow-weaver-chunk-FPPPU2DG.mjs";
+import {
+  getFriendlyError
+} from "./flow-weaver-chunk-S63Q3JIU.mjs";
+import "./flow-weaver-chunk-I4APCXYN.mjs";
+import "./flow-weaver-chunk-3ZLMPQTH.mjs";
+import "./flow-weaver-chunk-7ET6N32V.mjs";
+import "./flow-weaver-chunk-MMV2XGD3.mjs";
+import {
+  MissingParamsError,
+  missingParams
+} from "./flow-weaver-chunk-EKWF27G6.mjs";
+import {
+  executeWorkflow
+} from "./flow-weaver-chunk-GBUNNP33.mjs";
+import "./flow-weaver-chunk-NQKKWDGF.mjs";
+import "./flow-weaver-chunk-V6DHWFQG.mjs";
+import "./flow-weaver-chunk-4DVY73ML.mjs";
+import "./flow-weaver-chunk-ZQALO25T.mjs";
+import "./flow-weaver-chunk-DM4BBRRU.mjs";
+import "./flow-weaver-chunk-A6M5K3W7.mjs";
+import {
+  parseWorkflow
+} from "./flow-weaver-chunk-W3YNK26P.mjs";
+import "./flow-weaver-chunk-BHCC5FE5.mjs";
+import "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import "./flow-weaver-chunk-55QMUZIA.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import {
+  getTopologicalOrder
+} from "./flow-weaver-chunk-Z44JK332.mjs";
+import "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/cli/commands/run.ts
+import * as path from "path";
+import * as fs from "fs";
+import * as readline from "readline";
+import { randomUUID } from "node:crypto";
+function displayPath(filePath) {
+  const rel = path.relative(process.cwd(), filePath);
+  if (rel && !rel.startsWith("..") && rel.length < filePath.length) {
+    return rel;
+  }
+  return filePath;
+}
+async function runCommand(input, options) {
+  if (options.json) {
+    try {
+      await runCommandInner(input, options);
+    } catch (e) {
+      console.log(JSON.stringify({ success: false, error: getErrorMessage(e) }));
+      process.exitCode = 1;
+    }
+    return;
+  }
+  await runCommandInner(input, options);
+}
+async function runCommandInner(input, options) {
+  const filePath = path.resolve(input);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${displayPath(filePath)}`);
+  }
+  const params = readJsonObjectOption(options.params, options.paramsFile, "params") ?? {};
+  const mocks = readJsonObjectOption(options.mocks, options.mocksFile, "mocks");
+  if (mocks && !options.json) {
+    await validateMockConfig(mocks, filePath, options.workflow);
+  }
+  let timeoutId;
+  let timedOut = false;
+  if (options.timeout) {
+    timeoutId = setTimeout(() => {
+      timedOut = true;
+      const message = `Execution timed out after ${options.timeout}ms`;
+      if (options.json) {
+        process.stdout.write(JSON.stringify({ success: false, error: message }) + "\n");
+      } else {
+        logger.error(message);
+      }
+      process.exit(1);
+    }, options.timeout);
+  }
+  try {
+    const includeTrace = options.stream || options.trace || !options.production;
+    if (!options.json && mocks) {
+      logger.info("Running with mock data");
+    }
+    const parsed = await parseWorkflow(filePath, { workflowName: options.workflow, projectDir: path.dirname(filePath) });
+    if (parsed.errors.length === 0) {
+      const missing = missingParams(parsed.ast, params);
+      if (missing.length) throw new MissingParamsError(parsed.ast.functionName, missing);
+    }
+    const debugController = options.debug ? new DebugController({
+      debug: true,
+      breakpoints: options.breakpoint,
+      executionOrder: parsed.errors.length === 0 ? getTopologicalOrder(parsed.ast) : []
+    }) : void 0;
+    const nodeStartTimes = /* @__PURE__ */ new Map();
+    const onEvent = options.stream && !options.json ? (event) => {
+      if (event.type === "STATUS_CHANGED" && event.data) {
+        const nodeId = event.data.id;
+        const status = event.data.status;
+        if (!nodeId || !status) return;
+        if (status === "RUNNING") {
+          nodeStartTimes.set(nodeId, event.timestamp);
+          logger.log(`  [STATUS_CHANGED] ${nodeId}: \u2192 RUNNING`);
+        } else {
+          const startTime = nodeStartTimes.get(nodeId);
+          const duration = startTime ? ` (${event.timestamp - startTime}ms)` : "";
+          logger.log(`  [STATUS_CHANGED] ${nodeId}: \u2192 ${status}${duration}`);
+        }
+      } else if (event.type === "VARIABLE_SET" && event.data) {
+        const nodeId = event.data.nodeId;
+        const varName = event.data.name;
+        if (nodeId && varName) {
+          logger.log(`  [VARIABLE_SET] ${nodeId}.${varName}`);
+        }
+      }
+    } : void 0;
+    const runId = randomUUID();
+    const execPromise = executeWorkflow({
+      runId,
+      filePath,
+      params,
+      workflowName: options.workflow,
+      production: options.production ?? false,
+      includeTrace,
+      mocks,
+      debugController,
+      onEvent
+    });
+    if (options.debug && debugController && process.stdin.isTTY) {
+      const debugResult = await runDebugRepl(debugController, execPromise, options);
+      if (timedOut) return;
+      if (options.json) {
+        process.stdout.write(
+          JSON.stringify({
+            success: true,
+            result: debugResult
+          }, null, 2) + "\n"
+        );
+      } else {
+        logger.success("Debug session completed");
+        logger.newline();
+        logger.section("Result");
+        logger.log(JSON.stringify(debugResult, null, 2));
+      }
+      return;
+    }
+    const result = await execPromise;
+    if (timedOut) return;
+    if (result.kind === "yielded") {
+      throw new Error(
+        "fw run is not a durable coordinator and cannot persist a yielded continuation"
+      );
+    }
+    if (options.json) {
+      process.stdout.write(
+        JSON.stringify(
+          {
+            success: true,
+            workflow: result.functionName,
+            executionTime: result.executionTime,
+            result: result.result,
+            ...includeTrace && result.trace && { traceCount: result.trace.length }
+          },
+          null,
+          2
+        ) + "\n"
+      );
+    } else {
+      logger.success(`Workflow "${result.functionName}" completed in ${result.executionTime}ms`);
+      logger.newline();
+      logger.section("Result");
+      logger.log(JSON.stringify(result.result, null, 2));
+      const resultObj = result.result;
+      if (resultObj?.onFailure === true && !options.params && !options.paramsFile) {
+        logger.newline();
+        logger.warn(
+          "Tip: use --params to provide input. Run `fw describe <file>` to see expected inputs."
+        );
+      }
+      if (options.trace && !options.stream && result.trace && result.trace.length > 0) {
+        logger.newline();
+        logger.section("Trace");
+        logger.log(`${result.trace.length} events captured`);
+        const meaningful = result.trace.filter((e) => e.data?.nodeId || e.data?.id);
+        const preview = meaningful.slice(0, 5);
+        for (const event of preview) {
+          const nodeId = event.data?.nodeId || event.data?.id || "";
+          logger.log(`  [${event.type}] ${nodeId}`);
+        }
+        if (meaningful.length > 5) {
+          logger.log(`  ... and ${meaningful.length - 5} more events`);
+        }
+      }
+    }
+  } catch (error) {
+    const errorMsg = getErrorMessage(error);
+    const errorObj = error;
+    if (error instanceof MissingParamsError) {
+      logger.error(`Workflow execution failed: ${errorMsg}`);
+      logger.warn(`  Pass ${error.missing.length === 1 ? "it" : "them"} with --params '${JSON.stringify(Object.fromEntries(error.missing.map((k) => [k, "\u2026"])))}' or --params-file <file>. \`fw describe <file>\` lists the parameters and their types.`);
+    } else if (/durable gates? requires coordinator-verified/.test(errorMsg)) {
+      logger.error("Workflow execution failed: this workflow has durable gates, and `fw run` has nowhere to keep a run between one gate and the next.");
+      logger.warn("  Run it where runs are kept: `fw console` (answer gates on the page), `fw serve` (over HTTP), or the `fw_run` MCP tool from an assistant. From code, `createLocalCoordinator()` -- see `fw docs library`.");
+    } else if (errorObj.errors && Array.isArray(errorObj.errors)) {
+      logger.error(`Workflow execution failed:`);
+      for (const err of errorObj.errors) {
+        const friendly = getFriendlyError(err);
+        if (friendly) {
+          logger.error(`  ${friendly.title}: ${friendly.explanation}`);
+          logger.warn(`    How to fix: ${friendly.fix}`);
+        } else {
+          logger.error(`  - ${err.message}`);
+        }
+      }
+    } else if (errorObj.code) {
+      const friendly = getFriendlyError({ code: errorObj.code, message: errorMsg });
+      if (friendly) {
+        logger.error(`${friendly.title}: ${friendly.explanation}`);
+        logger.warn(`  How to fix: ${friendly.fix}`);
+      } else {
+        logger.error(`Workflow execution failed: ${errorMsg}`);
+      }
+    } else {
+      logger.error(`Workflow execution failed: ${errorMsg}`);
+    }
+    if (options.json) {
+      process.stdout.write(
+        JSON.stringify({ success: false, error: errorMsg }, null, 2) + "\n"
+      );
+      process.exitCode = 1;
+    } else {
+      process.exitCode = 1;
+    }
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+var VALID_MOCK_KEYS = /* @__PURE__ */ new Set(["events", "invocations", "agents", "gates", "fast"]);
+var MOCK_SECTION_TO_NODE = {
+  events: "waitForEvent",
+  invocations: "invokeWorkflow",
+  agents: "waitForAgent"
+};
+async function validateMockConfig(mocks, filePath, workflowName) {
+  for (const key of Object.keys(mocks)) {
+    if (!VALID_MOCK_KEYS.has(key)) {
+      logger.warn(`Mock config has unknown key "${key}". Valid keys: ${[...VALID_MOCK_KEYS].join(", ")}`);
+    }
+  }
+  try {
+    const result = await parseWorkflow(filePath, { workflowName, projectDir: path.dirname(filePath) });
+    if (result.errors.length > 0 || !result.ast?.instances) return;
+    const usedNodeTypes = new Set(result.ast.instances.map((i) => i.nodeType));
+    for (const [section, nodeType] of Object.entries(MOCK_SECTION_TO_NODE)) {
+      const mockSection = mocks[section];
+      if (mockSection && typeof mockSection === "object" && Object.keys(mockSection).length > 0) {
+        if (!usedNodeTypes.has(nodeType)) {
+          logger.warn(
+            `Mock config has "${section}" entries but workflow has no ${nodeType} nodes`
+          );
+        }
+      }
+    }
+  } catch {
+  }
+}
+function printDebugState(state) {
+  const pos = `${state.position + 1}/${state.executionOrder.length}`;
+  logger.log(`
+[paused] ${state.phase}: ${state.currentNodeId} (${pos})`);
+  if (state.phase === "after" && state.currentNodeOutputs) {
+    for (const [port, value] of Object.entries(state.currentNodeOutputs)) {
+      const valueStr = JSON.stringify(value);
+      const display = valueStr.length > 80 ? valueStr.substring(0, 77) + "..." : valueStr;
+      logger.log(`  ${state.currentNodeId}.${port} = ${display}`);
+    }
+  }
+}
+function printDebugHelp() {
+  logger.log("Commands:");
+  logger.log("  s, step             Step to next node");
+  logger.log("  c, continue         Run to completion");
+  logger.log("  cb                  Continue to next breakpoint");
+  logger.log("  i, inspect          Show all variables");
+  logger.log("  i <node>            Show variables for a specific node");
+  logger.log("  b <node>            Add breakpoint");
+  logger.log("  rb <node>           Remove breakpoint");
+  logger.log("  bl                  List breakpoints");
+  logger.log("  set <node>.<port> <json>  Modify a variable");
+  logger.log("  q, quit             Abort debug session");
+  logger.log("  h, help             Show this help");
+}
+async function runDebugRepl(controller, execPromise, options) {
+  if (!options.json) {
+    logger.newline();
+    logger.section("Flow Weaver Debug");
+    logger.log('Type "h" for help.');
+  }
+  const firstResult = await Promise.race([
+    execPromise.then((r) => ({ type: "completed", result: r })),
+    controller.onPause().then((state) => ({ type: "paused", state }))
+  ]);
+  if (firstResult.type === "completed") {
+    if (firstResult.result.kind === "yielded") {
+      throw new Error(
+        "fw run debug mode is not a durable coordinator and cannot persist a yielded continuation"
+      );
+    }
+    return firstResult.result.result;
+  }
+  let currentState = firstResult.state;
+  printDebugState(currentState);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    prompt: "> "
+  });
+  return new Promise((resolve2, reject) => {
+    let resolved = false;
+    function finish(value) {
+      if (resolved) return;
+      resolved = true;
+      rl.close();
+      resolve2(value);
+    }
+    function fail(err) {
+      if (resolved) return;
+      resolved = true;
+      rl.close();
+      reject(err);
+    }
+    async function handleResume() {
+      const raceResult = await Promise.race([
+        execPromise.then((r) => ({ type: "completed", result: r })),
+        controller.onPause().then((state) => ({ type: "paused", state }))
+      ]);
+      if (raceResult.type === "completed") {
+        const execResult = raceResult.result;
+        if (execResult.kind === "yielded") {
+          fail(
+            new Error(
+              "fw run debug mode is not a durable coordinator and cannot persist a yielded continuation"
+            )
+          );
+          return;
+        }
+        if (!options.json) {
+          logger.success(`
+Workflow ${execResult.kind} in ${execResult.executionTime}ms`);
+        }
+        finish(execResult.result);
+      } else if (raceResult.type === "paused") {
+        currentState = raceResult.state;
+        printDebugState(currentState);
+        rl.prompt();
+      }
+    }
+    async function handleLine(line) {
+      const input = line.trim();
+      if (!input) {
+        rl.prompt();
+        return;
+      }
+      const parts = input.split(/\s+/);
+      const cmd = parts[0].toLowerCase();
+      try {
+        switch (cmd) {
+          case "s":
+          case "step":
+            controller.resume({ type: "step" });
+            await handleResume();
+            break;
+          case "c":
+          case "continue":
+            controller.resume({ type: "continue" });
+            await handleResume();
+            break;
+          case "cb":
+            controller.resume({ type: "continueToBreakpoint" });
+            await handleResume();
+            break;
+          case "i":
+          case "inspect": {
+            const nodeId = parts[1];
+            if (nodeId) {
+              const prefix = `${nodeId}:`;
+              let found = false;
+              for (const [key, value] of Object.entries(currentState.variables)) {
+                if (key.startsWith(prefix)) {
+                  found = true;
+                  const portKey = key.substring(prefix.length);
+                  logger.log(`  ${nodeId}.${portKey} = ${JSON.stringify(value)}`);
+                }
+              }
+              if (!found) {
+                logger.log(`  No variables found for node "${nodeId}"`);
+              }
+            } else {
+              const byNode = /* @__PURE__ */ new Map();
+              for (const [key, value] of Object.entries(currentState.variables)) {
+                const firstColon = key.indexOf(":");
+                if (firstColon === -1) continue;
+                const node = key.substring(0, firstColon);
+                if (!byNode.has(node)) byNode.set(node, {});
+                byNode.get(node)[key.substring(firstColon + 1)] = value;
+              }
+              for (const [node, vars] of byNode) {
+                logger.log(`  ${node}:`);
+                for (const [port, value] of Object.entries(vars)) {
+                  const valueStr = JSON.stringify(value);
+                  const display = valueStr.length > 60 ? valueStr.substring(0, 57) + "..." : valueStr;
+                  logger.log(`    ${port} = ${display}`);
+                }
+              }
+            }
+            rl.prompt();
+            break;
+          }
+          case "b": {
+            const nodeId = parts[1];
+            if (!nodeId) {
+              logger.log("Usage: b <nodeId>");
+            } else {
+              controller.addBreakpoint(nodeId);
+              logger.log(`Breakpoint added: ${nodeId}`);
+            }
+            rl.prompt();
+            break;
+          }
+          case "rb": {
+            const nodeId = parts[1];
+            if (!nodeId) {
+              logger.log("Usage: rb <nodeId>");
+            } else {
+              controller.removeBreakpoint(nodeId);
+              logger.log(`Breakpoint removed: ${nodeId}`);
+            }
+            rl.prompt();
+            break;
+          }
+          case "bl":
+            logger.log(`Breakpoints: ${controller.getBreakpoints().join(", ") || "(none)"}`);
+            rl.prompt();
+            break;
+          case "set": {
+            const target = parts[1];
+            const jsonValue = parts.slice(2).join(" ");
+            if (!target || !jsonValue) {
+              logger.log("Usage: set <node>.<port> <json_value>");
+              rl.prompt();
+              break;
+            }
+            const dotIdx = target.indexOf(".");
+            if (dotIdx === -1) {
+              logger.log("Target must be in format: node.port");
+              rl.prompt();
+              break;
+            }
+            const nodeId = target.substring(0, dotIdx);
+            const portName = target.substring(dotIdx + 1);
+            let value;
+            try {
+              value = JSON.parse(jsonValue);
+            } catch {
+              logger.log(`Invalid JSON value: ${jsonValue}`);
+              rl.prompt();
+              break;
+            }
+            const prefix = `${nodeId}:${portName}:`;
+            let foundKey = null;
+            let latestIdx = -1;
+            for (const key of Object.keys(currentState.variables)) {
+              if (key.startsWith(prefix)) {
+                const idx = parseInt(key.substring(prefix.length), 10);
+                if (idx > latestIdx) {
+                  latestIdx = idx;
+                  foundKey = key;
+                }
+              }
+            }
+            if (!foundKey) {
+              logger.log(`Variable not found: ${nodeId}.${portName}`);
+              rl.prompt();
+              break;
+            }
+            controller.setVariable(foundKey, value);
+            currentState.variables[foundKey] = value;
+            logger.log(`Set ${nodeId}.${portName} = ${JSON.stringify(value)}`);
+            rl.prompt();
+            break;
+          }
+          case "q":
+          case "quit":
+            controller.resume({ type: "abort" });
+            finish(void 0);
+            break;
+          case "h":
+          case "help":
+            printDebugHelp();
+            rl.prompt();
+            break;
+          default:
+            logger.log(`Unknown command: ${cmd}. Type "h" for help.`);
+            rl.prompt();
+        }
+      } catch (err) {
+        if (!resolved) {
+          const msg = getErrorMessage(err);
+          if (msg.includes("aborted")) {
+            logger.log("Debug session aborted.");
+            finish(void 0);
+          } else {
+            logger.error(`Error: ${msg}`);
+            rl.prompt();
+          }
+        }
+      }
+    }
+    rl.on("line", (line) => {
+      handleLine(line).catch((err) => fail(err instanceof Error ? err : new Error(String(err))));
+    });
+    rl.on("close", () => {
+      if (!resolved) {
+        finish(void 0);
+      }
+    });
+    rl.prompt();
+  });
+}
+export {
+  runCommand,
+  validateMockConfig
+};

package/dist/cli/flow-weaver-serialization-node-LE6PCG4M.mjs

@@ -0,0 +1,50 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/ast/serialization-node.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+// src/ast/serialization.ts
+function serializeAST(ast, pretty = true) {
+  return pretty ? JSON.stringify(ast, null, 2) : JSON.stringify(ast);
+}
+function deserializeAST(json) {
+  const ast = JSON.parse(json);
+  if (ast.type !== "Workflow") {
+    throw new Error('Invalid AST: root node must be of type "Workflow"');
+  }
+  return ast;
+}
+
+// src/ast/serialization-node.ts
+async function saveAST(ast, filePath) {
+  const json = serializeAST(ast, true);
+  await fs.writeFile(filePath, json, "utf-8");
+}
+async function loadAST(filePath) {
+  const json = await fs.readFile(filePath, "utf-8");
+  return deserializeAST(json);
+}
+async function saveASTAlongside(ast) {
+  const sourceFile = ast.sourceFile;
+  const dir = path.dirname(sourceFile);
+  const basename2 = path.basename(sourceFile, path.extname(sourceFile));
+  const astFile = path.join(dir, `${basename2}.ast.json`);
+  await saveAST(ast, astFile);
+  return astFile;
+}
+async function loadASTAlongside(sourceFile) {
+  const dir = path.dirname(sourceFile);
+  const basename2 = path.basename(sourceFile, path.extname(sourceFile));
+  const astFile = path.join(dir, `${basename2}.ast.json`);
+  return loadAST(astFile);
+}
+export {
+  loadAST,
+  loadASTAlongside,
+  saveAST,
+  saveASTAlongside
+};