amalgm 0.1.51 → 0.1.52

package/runtime/scripts/amalgm-mcp/automations/cell-references.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const CONTEXT_KEYS = new Set([
+  'automation',
+  'trigger',
+  'workflow',
+  'event',
+  'payload',
+  'headers',
+  'previous',
+  'outputs',
+  'cells',
+  'secrets',
+  'stop',
+]);
+
+const NON_CELL_PROPERTIES = new Set([
+  'constructor',
+  'hasOwnProperty',
+  'isPrototypeOf',
+  'propertyIsEnumerable',
+  'toLocaleString',
+  'toString',
+  'valueOf',
+]);
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isFunctionRef(value) {
+  return isObject(value) && typeof value.$fn === 'string';
+}
+
+function buildCodeMask(sourceText) {
+  const source = String(sourceText || '');
+  const mask = new Array(source.length).fill(true);
+  let state = 'code';
+  let quote = null;
+  let escaped = false;
+
+  for (let i = 0; i < source.length; i += 1) {
+    const char = source[i];
+    const next = source[i + 1];
+
+    if (state === 'line_comment') {
+      mask[i] = false;
+      if (char === '\n') state = 'code';
+      continue;
+    }
+
+    if (state === 'block_comment') {
+      mask[i] = false;
+      if (char === '*' && next === '/') {
+        mask[i + 1] = false;
+        i += 1;
+        state = 'code';
+      }
+      continue;
+    }
+
+    if (state === 'string') {
+      mask[i] = false;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        state = 'code';
+        quote = null;
+      }
+      continue;
+    }
+
+    if (state === 'template') {
+      mask[i] = false;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '`') {
+        state = 'code';
+      }
+      continue;
+    }
+
+    if (char === '/' && next === '/') {
+      mask[i] = false;
+      mask[i + 1] = false;
+      i += 1;
+      state = 'line_comment';
+      continue;
+    }
+
+    if (char === '/' && next === '*') {
+      mask[i] = false;
+      mask[i + 1] = false;
+      i += 1;
+      state = 'block_comment';
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      mask[i] = false;
+      quote = char;
+      escaped = false;
+      state = 'string';
+      continue;
+    }
+
+    if (char === '`') {
+      mask[i] = false;
+      escaped = false;
+      state = 'template';
+    }
+  }
+
+  return mask;
+}
+
+function codeIndex(match, token) {
+  const relative = match[0].search(new RegExp(`\\b${token}\\b`));
+  return relative === -1 ? match.index : match.index + relative;
+}
+
+function pushRef(refs, source, mask, match, token, name) {
+  const baseIndex = codeIndex(match, token);
+  if (!mask[baseIndex]) return;
+  const cleanName = String(name || '').trim();
+  if (!cleanName || NON_CELL_PROPERTIES.has(cleanName)) return;
+  refs.push({ name: cleanName, source });
+}
+
+function extractCellReferences(sourceText) {
+  const source = String(sourceText || '');
+  const mask = buildCodeMask(source);
+  const refs = [];
+  const member = '\\s*(?:\\?\\.|\\.)\\s*';
+  const optionalMember = '\\s*(?:\\?\\.)?\\s*';
+  const patterns = [
+    { source: 'cells', token: 'cells', re: new RegExp(`\\b(?:ctx${member})?cells${member}([A-Za-z_$][\\w$]*)`, 'g') },
+    { source: 'cells', token: 'cells', re: new RegExp(`\\b(?:ctx${member})?cells${optionalMember}\\[\\s*['"]([^'"]+)['"]\\s*\\]`, 'g') },
+    { source: 'outputs', token: 'outputs', re: new RegExp(`\\b(?:ctx${member})?outputs${member}([A-Za-z_$][\\w$]*)`, 'g') },
+    { source: 'outputs', token: 'outputs', re: new RegExp(`\\b(?:ctx${member})?outputs${optionalMember}\\[\\s*['"]([^'"]+)['"]\\s*\\]`, 'g') },
+  ];
+
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.re.exec(source)) !== null) {
+      pushRef(refs, pattern.source, mask, match, pattern.token, match[1]);
+    }
+  }
+
+  const ctxAliasPattern = /\bctx\s*(?:\?\.)?\s*\.\s*([A-Za-z_$][\w$]*)/g;
+  let match;
+  while ((match = ctxAliasPattern.exec(source)) !== null) {
+    if (!mask[match.index]) continue;
+    const name = String(match[1] || '').trim();
+    if (!name || CONTEXT_KEYS.has(name) || NON_CELL_PROPERTIES.has(name)) continue;
+    refs.push({ name, source: 'ctx' });
+  }
+
+  return refs;
+}
+
+function collectFunctionSources(value, label, sources) {
+  if (isFunctionRef(value)) {
+    sources.push({ label, source: value.$fn });
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => collectFunctionSources(item, `${label}[${index}]`, sources));
+    return;
+  }
+  if (isObject(value)) {
+    for (const [key, child] of Object.entries(value)) {
+      collectFunctionSources(child, `${label}.${key}`, sources);
+    }
+  }
+}
+
+function functionSourcesForCell(cell) {
+  const sources = [];
+  if (typeof cell.code === 'string') sources.push({ label: 'code', source: cell.code });
+  collectFunctionSources(cell.if, 'if', sources);
+  collectFunctionSources(cell.args, 'args', sources);
+  collectFunctionSources(cell.config, 'config', sources);
+  return sources;
+}
+
+function validateCellReferences(ir) {
+  const cells = Array.isArray(ir?.cells) ? ir.cells : [];
+  const declared = cells.map((cell) => cell.name).filter(Boolean);
+  const declaredSet = new Set(declared);
+  const seen = new Set();
+  const errors = [];
+
+  for (const cell of cells) {
+    const reported = new Set();
+    for (const fn of functionSourcesForCell(cell)) {
+      for (const ref of extractCellReferences(fn.source)) {
+        const key = `${ref.name}:${fn.label}`;
+        if (reported.has(key)) continue;
+        reported.add(key);
+
+        if (!declaredSet.has(ref.name)) {
+          errors.push({
+            phase: 'static',
+            cell: cell.name,
+            reference: ref.name,
+            source: ref.source,
+            message: `Cell "${cell.name}" references unknown cell "${ref.name}" in ${fn.label}. Declared cells: ${declared.join(', ') || '(none)'}.`,
+          });
+        } else if (!seen.has(ref.name)) {
+          const self = ref.name === cell.name;
+          errors.push({
+            phase: 'static',
+            cell: cell.name,
+            reference: ref.name,
+            source: ref.source,
+            message: self
+              ? `Cell "${cell.name}" references its own output in ${fn.label}, but a cell output is only available after that cell finishes.`
+              : `Cell "${cell.name}" references cell "${ref.name}" in ${fn.label} before it has run. Move "${ref.name}" earlier in cells[].`,
+          });
+        }
+      }
+    }
+    seen.add(cell.name);
+  }
+
+  return errors;
+}
+
+module.exports = {
+  extractCellReferences,
+  validateCellReferences,
+};

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

@@ -0,0 +1,41 @@
+'use strict';
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function buildCells(outputs = {}) {
+  const cells = {};
+  for (const [name, output] of Object.entries(outputs || {})) {
+    cells[name] = isObject(output)
+      ? { ...output, output }
+      : { output, value: output };
+  }
+  return cells;
+}
+
+function buildWorkflowInput(ctx, stop) {
+  const outputs = ctx.outputs || {};
+  const cells = buildCells(outputs);
+
+  return {
+    automation: ctx.automation,
+    event: ctx.event,
+    payload: ctx.event?.payload,
+    headers: ctx.event?.headers || {},
+    trigger: ctx.trigger,
+    workflow: ctx.workflow,
+    previous: ctx.previous,
+    outputs,
+    cells,
+    steps: cells,
+    secrets: ctx.secrets,
+    stop,
+    ...outputs,
+  };
+}
+
+module.exports = {
+  buildCells,
+  buildWorkflowInput,
+};

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

@@ -0,0 +1,148 @@
+'use strict';
+
+/**
+ * /automations/* REST routes for the control pane.
+ */
+
+const {
+  createAutomation,
+  deleteAutomation,
+  deleteAutomationByTriggerId,
+  getAutomation,
+  getAutomationByTriggerId,
+  listAutomationRuns,
+  listAutomations,
+  listTriggers,
+  listWorkflows,
+  updateAutomation,
+  updateAutomationByTriggerId,
+} = require('./store');
+const { executeAutomationById } = require('./runner');
+const { validateWorkflowText } = require('./validator');
+
+function sendError(sendJson, status, error) {
+  sendJson(status, { error: error.message || String(error) });
+}
+
+async function handleList(_req, sendJson) {
+  sendJson(200, {
+    automations: listAutomations(),
+    triggers: listTriggers(),
+    workflows: listWorkflows(),
+  });
+}
+
+async function handleGet(body, sendJson) {
+  const automationId = body?.automation_id || body?.automationId;
+  const triggerId = body?.trigger_id || body?.triggerId;
+  const automation = automationId
+    ? getAutomation(automationId)
+    : triggerId
+      ? getAutomationByTriggerId(triggerId)
+      : null;
+  if (!automation) return sendJson(404, { error: 'Automation not found' });
+  sendJson(200, {
+    automation,
+    runs: listAutomationRuns({ automationId: automation.id, limit: 50 }),
+  });
+}
+
+async function handleCreate(body, sendJson) {
+  try {
+    const automation = createAutomation(body || {}, { source: 'automations:rest:create' });
+    sendJson(200, { ok: true, automation, trigger: automation.triggers[0] || null, workflow: automation.workflow });
+  } catch (error) {
+    sendError(sendJson, 400, error);
+  }
+}
+
+async function handleValidate(body, sendJson) {
+  try {
+    const workflowText = body?.workflowText || body?.workflow;
+    if (typeof workflowText !== 'string' || !workflowText.trim()) {
+      return sendJson(400, { error: 'workflowText is required' });
+    }
+    const validation = await validateWorkflowText(workflowText, body || {});
+    sendJson(validation.ok ? 200 : 400, validation);
+  } catch (error) {
+    sendError(sendJson, 400, error);
+  }
+}
+
+async function handleUpdate(body, sendJson) {
+  try {
+    const { automation_id, automationId, workflow, ...updates } = body || {};
+    const id = automation_id || automationId;
+    if (!id) return sendJson(400, { error: 'automation_id is required' });
+    const automation = updateAutomation(id, {
+      ...updates,
+      ...(workflow !== undefined && updates.workflowText === undefined ? { workflowText: workflow } : {}),
+    }, { source: 'automations:rest:update' });
+    sendJson(200, { ok: true, automation, trigger: automation.triggers[0] || null, workflow: automation.workflow });
+  } catch (error) {
+    sendError(sendJson, 400, error);
+  }
+}
+
+async function handleDelete(body, sendJson) {
+  try {
+    const id = body?.automation_id || body?.automationId;
+    if (!id) return sendJson(400, { error: 'automation_id is required' });
+    const deleted = deleteAutomation(id, { source: 'automations:rest:delete' });
+    sendJson(200, { ok: true, deleted });
+  } catch (error) {
+    sendError(sendJson, 400, error);
+  }
+}
+
+async function handleRunNow(body, sendJson) {
+  try {
+    const id = body?.automation_id || body?.automationId;
+    if (!id) return sendJson(400, { error: 'automation_id is required' });
+    const run = await executeAutomationById(id, {
+      id: `manual:${Date.now()}`,
+      source: 'amalgm.manual',
+      event: 'run_now',
+      payload: body?.payload || {},
+      headers: {},
+      receivedAt: new Date().toISOString(),
+    }, { triggerId: body?.trigger_id || body?.triggerId });
+    sendJson(200, { ok: true, run });
+  } catch (error) {
+    sendError(sendJson, 400, error);
+  }
+}
+
+async function handleTriggerUpdate(body, sendJson) {
+  try {
+    const id = body?.trigger_id || body?.triggerId;
+    if (!id) return sendJson(400, { error: 'trigger_id is required' });
+    const automation = updateAutomationByTriggerId(id, body || {}, { source: 'automations:rest:trigger-update' });
+    sendJson(200, { ok: true, automation, trigger: automation.triggers.find((trigger) => trigger.id === id) || null, workflow: automation.workflow });
+  } catch (error) {
+    sendError(sendJson, 400, error);
+  }
+}
+
+async function handleTriggerDelete(body, sendJson) {
+  try {
+    const id = body?.trigger_id || body?.triggerId;
+    if (!id) return sendJson(400, { error: 'trigger_id is required' });
+    const deleted = deleteAutomationByTriggerId(id, { source: 'automations:rest:trigger-delete' });
+    sendJson(200, { ok: true, deleted });
+  } catch (error) {
+    sendError(sendJson, 400, error);
+  }
+}
+
+module.exports = {
+  handleCreate,
+  handleDelete,
+  handleGet,
+  handleList,
+  handleRunNow,
+  handleTriggerDelete,
+  handleTriggerUpdate,
+  handleUpdate,
+  handleValidate,
+};