amalgm 0.1.51 → 0.1.52

package/runtime/scripts/amalgm-mcp/automations/validator.js

@@ -0,0 +1,225 @@
+'use strict';
+
+const { compileWorkflowText } = require('../workflows/compiler');
+const { buildWorkflowInput } = require('./context');
+const { runFunctionSource } = require('./runner');
+const { validateCellReferences } = require('./cell-references');
+const { validateWorkflowToolActions } = require('./tool-actions');
+
+const DEFAULT_VALIDATE_CODE_TIMEOUT_MS = 5_000;
+
+class ValidationStop extends Error {
+  constructor() {
+    super('Workflow stopped');
+    this.name = 'ValidationStop';
+  }
+}
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isFunctionRef(value) {
+  return isObject(value) && typeof value.$fn === 'string';
+}
+
+async function resolveDynamic(value, input, options = {}) {
+  if (isFunctionRef(value)) return runFunctionSource(value.$fn, input, options);
+  if (Array.isArray(value)) {
+    const next = [];
+    for (const item of value) next.push(await resolveDynamic(item, input, options));
+    return next;
+  }
+  if (isObject(value)) {
+    const next = {};
+    for (const [key, child] of Object.entries(value)) {
+      next[key] = await resolveDynamic(child, input, options);
+    }
+    return next;
+  }
+  return value;
+}
+
+function defaultEventFor(ir, input = {}) {
+  return {
+    id: input.id || 'validate:event',
+    source: input.source || ir.trigger?.source || 'amalgm.validate',
+    event: input.event || ir.trigger?.event || 'dry_run',
+    payload: isObject(input.payload) ? input.payload : {},
+    headers: isObject(input.headers) ? input.headers : {},
+    receivedAt: new Date().toISOString(),
+  };
+}
+
+function defaultDryOutput(cell, resolved) {
+  if (cell.kind === 'cli') {
+    return {
+      dryRun: true,
+      kind: 'cli',
+      command: resolved.command || resolved.run || '',
+      cwd: resolved.cwd || null,
+    };
+  }
+  return {
+    dryRun: true,
+    kind: 'tool',
+    toolId: cell.toolId,
+    actionName: cell.actionName,
+    args: resolved,
+  };
+}
+
+async function validateDryRun(ir, options = {}) {
+  const event = defaultEventFor(ir, options.event);
+  const codeTimeoutMs = Number(options.codeTimeoutMs || options.code_timeout_ms) || DEFAULT_VALIDATE_CODE_TIMEOUT_MS;
+  const mockOutputs = isObject(options.mockOutputs || options.mock_outputs)
+    ? (options.mockOutputs || options.mock_outputs)
+    : {};
+  const executeCode = options.executeCode !== false && options.execute_code !== false;
+  const ctx = {
+    automation: { id: 'validate:automation', name: options.name || 'Validation automation' },
+    event,
+    trigger: {
+      id: 'validate:trigger',
+      name: 'Validation trigger',
+      kind: 'event',
+      source: event.source,
+      event: event.event,
+    },
+    workflow: { id: 'validate:workflow', name: 'Validation workflow' },
+    previous: null,
+    outputs: {},
+    secrets: {},
+  };
+  const cells = [];
+
+  for (const cell of ir.cells) {
+    const input = buildWorkflowInput(ctx, () => {
+      throw new ValidationStop();
+    });
+    const record = {
+      name: cell.name,
+      kind: cell.kind,
+      status: 'completed',
+    };
+
+    try {
+      if (cell.if !== undefined) {
+        const condition = await resolveDynamic(cell.if, input, { timeoutMs: codeTimeoutMs });
+        if (!condition) {
+          record.status = 'skipped';
+          record.output = null;
+          cells.push(record);
+          continue;
+        }
+      }
+
+      let output;
+      if (Object.prototype.hasOwnProperty.call(mockOutputs, cell.name)) {
+        output = mockOutputs[cell.name];
+      } else if (cell.kind === 'code') {
+        output = executeCode
+          ? await runFunctionSource(cell.code, input, { timeoutMs: codeTimeoutMs })
+          : { dryRun: true, kind: 'code' };
+      } else if (cell.kind === 'cli') {
+        const config = await resolveDynamic(cell.config || {}, input, { timeoutMs: codeTimeoutMs });
+        output = defaultDryOutput(cell, config);
+      } else if (cell.kind === 'tool') {
+        const args = await resolveDynamic(cell.args || {}, input, { timeoutMs: codeTimeoutMs });
+        output = defaultDryOutput(cell, args);
+      } else {
+        throw new Error(`Unsupported workflow cell kind "${cell.kind}".`);
+      }
+
+      ctx.previous = output;
+      ctx.outputs[cell.name] = output;
+      record.output = output;
+      cells.push(record);
+    } catch (error) {
+      const stopped = error instanceof ValidationStop || error?.name === 'ValidationStop';
+      record.status = stopped ? 'stopped' : 'failed';
+      record.error = stopped ? null : (error.message || String(error));
+      cells.push(record);
+      return {
+        ok: false,
+        errors: stopped ? [] : [{
+          cell: cell.name,
+          message: record.error,
+        }],
+        dryRun: {
+          status: record.status,
+          cells,
+          output: ctx.outputs,
+        },
+      };
+    }
+  }
+
+  return {
+    ok: true,
+    errors: [],
+    dryRun: {
+      status: 'completed',
+      cells,
+      output: ctx.outputs,
+    },
+  };
+}
+
+async function validateWorkflowText(workflowText, options = {}) {
+  let ir;
+  try {
+    ir = compileWorkflowText(workflowText);
+  } catch (error) {
+    return {
+      ok: false,
+      errors: [{ phase: 'compile', message: error.message || String(error) }],
+    };
+  }
+
+  const result = {
+    ok: true,
+    errors: [],
+    workflowIr: ir,
+    summary: {
+      trigger: ir.trigger,
+      cells: ir.cells.map((cell) => ({
+        name: cell.name,
+        kind: cell.kind,
+        ...(cell.kind === 'tool' ? { toolId: cell.toolId, actionName: cell.actionName } : {}),
+      })),
+    },
+  };
+
+  const staticErrors = validateCellReferences(ir);
+  if (staticErrors.length > 0) {
+    return {
+      ...result,
+      ok: false,
+      errors: staticErrors,
+    };
+  }
+
+  const toolActionErrors = validateWorkflowToolActions(ir);
+  if (toolActionErrors.length > 0) {
+    return {
+      ...result,
+      ok: false,
+      errors: toolActionErrors,
+    };
+  }
+
+  if (options.dryRun === false || options.dry_run === false) return result;
+
+  const dryRun = await validateDryRun(ir, options);
+  return {
+    ...result,
+    ...dryRun,
+    workflowIr: ir,
+    summary: result.summary,
+  };
+}
+
+module.exports = {
+  validateWorkflowText,
+};