amalgm 0.1.51 → 0.1.53

package/runtime/scripts/amalgm-mcp/tests/automations-store-runner.test.js

@@ -0,0 +1,348 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-automations-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+
+const { closeLocalDb } = require('../state/db');
+const {
+  claimDueScheduledTriggers,
+  createAutomation,
+  listAutomationRuns,
+  listTriggers,
+  listWorkflowCellRuns,
+  updateAutomationByTriggerId,
+} = require('../automations/store');
+const { executeAutomation } = require('../automations/runner');
+const { validateWorkflowText } = require('../automations/validator');
+const { compileWorkflowText } = require('../workflows/compiler');
+const { buildSnapshot } = require('../state/snapshot');
+const automationTools = require('../automations/tools');
+const { upsertTool } = require('../toolbox/store');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('automation stores trigger plus workflow in local live SQLite resources', () => {
+  const automation = createAutomation({
+    id: 'automation-webhook',
+    name: 'Webhook automation',
+    triggers: [{ id: 'trigger-webhook', kind: 'event', source: 'github', event: 'push' }],
+    workflowText: `export default workflow({
+  trigger: event("github.push"),
+  cells: [code("ok", async ({ payload }) => ({ ref: payload.ref }))]
+})`,
+  });
+
+  assert.equal(automation.triggers.length, 1);
+  assert.equal(automation.workflows.length, 1);
+  assert.equal(automation.triggers[0].kind, 'event');
+
+  const snapshot = buildSnapshot('automations,triggers,workflows');
+  assert.equal(snapshot.resources.automations.some((item) => item.id === 'automation-webhook'), true);
+  assert.equal(snapshot.resources.triggers.some((item) => item.id === 'trigger-webhook'), true);
+  assert.equal(snapshot.resources.workflows.some((item) => item.id === automation.workflowId), true);
+});
+
+test('trigger update changes trigger fields without renaming parent automation', () => {
+  const automation = createAutomation({
+    id: 'automation-trigger-edit',
+    name: 'Parent automation',
+    triggers: [{ id: 'trigger-edit-target', kind: 'event', event: 'push' }],
+    workflowText: `export default workflow({
+  trigger: event("github.push"),
+  cells: [code("ok", async () => "done")]
+})`,
+  });
+
+  const updated = updateAutomationByTriggerId('trigger-edit-target', {
+    name: 'Edited trigger',
+    description: 'Only the trigger should change',
+    event: 'release',
+    sourceUrl: 'https://example.test/webhook',
+  });
+
+  assert.equal(updated.id, automation.id);
+  assert.equal(updated.name, 'Parent automation');
+  assert.equal(updated.triggers[0].name, 'Edited trigger');
+  assert.equal(updated.triggers[0].description, 'Only the trigger should change');
+  assert.equal(updated.triggers[0].event, 'release');
+  assert.equal(updated.triggers[0].sourceUrl, 'https://example.test/webhook');
+});
+
+test('automation runner records unified run and cell receipts', async () => {
+  const automation = buildSnapshot('automations').resources.automations
+    .find((item) => item.id === 'automation-webhook');
+  const run = await executeAutomation(automation, automation.triggers[0], {
+    source: 'github',
+    event: 'push',
+    payload: { ref: 'refs/heads/main' },
+    headers: {},
+  });
+
+  assert.equal(run.status, 'completed');
+  assert.equal(run.output.ok.ref, 'refs/heads/main');
+  assert.equal(listAutomationRuns({ automationId: automation.id }).length, 1);
+  assert.equal(listWorkflowCellRuns({ runId: run.id }).length, 1);
+});
+
+test('scheduled trigger claims run once and disables one-shot trigger', () => {
+  createAutomation({
+    id: 'automation-scheduled',
+    name: 'Scheduled automation',
+    triggers: [{
+      id: 'trigger-scheduled',
+      kind: 'scheduled',
+      schedule: { kind: 'once', at: '2026-05-18T16:00:00.000Z' },
+    }],
+    workflowText: `export default workflow({
+  trigger: event("scheduled.run"),
+  cells: [code("ok", async () => "done")]
+})`,
+  });
+
+  const claims = claimDueScheduledTriggers(new Date('2026-05-18T16:00:01.000Z'));
+  assert.equal(claims.length, 1);
+  const trigger = listTriggers().find((item) => item.id === 'trigger-scheduled');
+  assert.equal(trigger.enabled, false);
+  assert.equal(trigger.nextRunAt, null);
+});
+
+test('workflow ctx exposes previous cell outputs through cells aliases', async () => {
+  const automation = createAutomation({
+    id: 'automation-cells-context',
+    name: 'Cells context automation',
+    triggers: [{ id: 'trigger-cells-context', kind: 'event', source: 'test', event: 'cells' }],
+    workflowText: `export default workflow({
+  trigger: event("test.cells"),
+  cells: [
+    code("greet", async () => ({ message: "hello" })),
+    code("read", async ({ cells, outputs, greet }) => ({
+      viaOutput: cells.greet.output.message,
+      viaAlias: cells.greet.message,
+      viaOutputs: outputs.greet.message,
+      viaTopLevel: greet.message
+    }))
+  ]
+})`,
+  });
+
+  const run = await executeAutomation(automation, automation.triggers[0], {
+    source: 'test',
+    event: 'cells',
+    payload: {},
+    headers: {},
+  });
+
+  assert.equal(run.status, 'completed');
+  assert.deepEqual(JSON.parse(JSON.stringify(run.output.read)), {
+    viaOutput: 'hello',
+    viaAlias: 'hello',
+    viaOutputs: 'hello',
+    viaTopLevel: 'hello',
+  });
+});
+
+test('workflow compiler accepts compact tool and agent helpers', () => {
+  const ir = compileWorkflowText(`export default workflow({
+  trigger: event("github.push"),
+  cells: [
+    code("greet", async () => ({ message: "hello" })),
+    tool("notify", "amalgm.notify_user", ({ cells }) => ({ message: cells.greet.output.message })),
+    agent("ask_codex", "Codex", { prompt: "Review this", run_in_background: true })
+  ]
+})`);
+
+  assert.equal(ir.cells[1].toolId, 'amalgm');
+  assert.equal(ir.cells[1].actionName, 'notify_user');
+  assert.equal(ir.cells[2].toolId, 'amalgm');
+  assert.equal(ir.cells[2].actionName, 'talk_to_agent');
+  assert.equal(ir.cells[2].args.agent, 'Codex');
+});
+
+test('workflow compiler splits dotted toolbox action refs on the last dot', () => {
+  const ir = compileWorkflowText(`export default workflow({
+  trigger: event("test.dotted"),
+  cells: [
+    tool("quote", "codex.yahoo_stock_price.run", { symbol: "AAPL" })
+  ]
+})`);
+
+  assert.equal(ir.cells[0].toolId, 'codex.yahoo_stock_price');
+  assert.equal(ir.cells[0].actionName, 'run');
+});
+
+test('automation validator catches dry-run cell reference failures without persistence', async () => {
+  const valid = await validateWorkflowText(`export default workflow({
+  trigger: event("test.validate"),
+  cells: [
+    code("greet", async () => ({ message: "hello" })),
+    tool("notify", "amalgm.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))
+  ]
+})`);
+
+  assert.equal(valid.ok, true);
+  assert.equal(valid.dryRun.cells[1].output.args.message, 'hello');
+
+  const invalid = await validateWorkflowText(`export default workflow({
+  trigger: event("test.validate"),
+  cells: [
+    code("greet", async () => ({ message: "hello" })),
+    tool("notify", "amalgm.notify_user", ({ cells }) => ({ message: cells.missing.output.message }))
+  ]
+})`);
+
+  assert.equal(invalid.ok, false);
+  assert.equal(invalid.errors[0].cell, 'notify');
+  assert.equal(invalid.errors[0].phase, 'static');
+  assert.match(invalid.errors[0].message, /unknown cell "missing"/);
+});
+
+test('automation validator catches unknown tool actions before dry run', async () => {
+  const invalid = await validateWorkflowText(`export default workflow({
+  trigger: event("test.validate"),
+  cells: [
+    tool("quote", "codex.yahoo_stock_price.run", { symbol: "AAPL" })
+  ]
+})`);
+
+  assert.equal(invalid.ok, false);
+  assert.equal(invalid.errors[0].phase, 'static');
+  assert.equal(invalid.errors[0].cell, 'quote');
+  assert.match(invalid.errors[0].message, /Tool action "codex\.yahoo_stock_price\.run" was not found/);
+});
+
+test('dotted toolbox action refs validate and run after the action is registered', async () => {
+  upsertTool({
+    id: 'codex.yahoo_stock_price',
+    name: 'Yahoo Stock Price',
+    type: 'cli',
+    source: {
+      command: process.execPath,
+      args: ['-e', 'let s=""; process.stdin.on("data", d => s += d); process.stdin.on("end", () => { const input = JSON.parse(s); console.log(JSON.stringify({ symbol: input.symbol, price: 123.45 })); });'],
+      inputMode: 'json-stdin',
+      outputMode: 'json',
+    },
+  });
+
+  const workflowText = `export default workflow({
+  trigger: event("test.quote"),
+  cells: [
+    tool("quote", "codex.yahoo_stock_price.run", { symbol: "AAPL" })
+  ]
+})`;
+  const valid = await validateWorkflowText(workflowText);
+  assert.equal(valid.ok, true);
+
+  const automation = createAutomation({
+    id: 'automation-dotted-toolbox',
+    name: 'Dotted toolbox automation',
+    triggers: [{ id: 'trigger-dotted-toolbox', kind: 'event', source: 'test', event: 'quote' }],
+    workflowText,
+  });
+  const run = await executeAutomation(automation, automation.triggers[0], {
+    source: 'test',
+    event: 'quote',
+    payload: {},
+    headers: {},
+  });
+
+  assert.equal(run.status, 'completed');
+  assert.equal(run.output.quote.symbol, 'AAPL');
+  assert.equal(run.output.quote.price, 123.45);
+});
+
+test('automation validator catches out-of-order references before dry run', async () => {
+  const invalid = await validateWorkflowText(`export default workflow({
+  trigger: event("test.validate"),
+  cells: [
+    code("read", async ({ cells }) => cells.greet.output.message),
+    code("greet", async () => ({ message: "hello" }))
+  ]
+})`);
+
+  assert.equal(invalid.ok, false);
+  assert.equal(invalid.errors[0].phase, 'static');
+  assert.equal(invalid.errors[0].cell, 'read');
+  assert.match(invalid.errors[0].message, /before it has run/);
+});
+
+test('automation create rejects static cell reference errors', () => {
+  assert.throws(() => createAutomation({
+    id: 'automation-invalid-reference',
+    name: 'Invalid reference automation',
+    triggers: [{ id: 'trigger-invalid-reference', kind: 'event', source: 'test', event: 'invalid' }],
+    workflowText: `export default workflow({
+  trigger: event("test.invalid"),
+  cells: [
+    code("read", async ({ cells }) => cells.missing.output.message)
+  ]
+})`,
+  }), /unknown cell "missing"/);
+});
+
+test('automation validator uses mock_outputs for dry-run tool consumers', async () => {
+  const valid = await validateWorkflowText(`export default workflow({
+  trigger: event("test.validate"),
+  cells: [
+    tool("ping", "http.fetch", { url: "https://example.com" }),
+    code("read", async ({ cells }) => cells.ping.output.body.url)
+  ]
+})`, {
+    mock_outputs: {
+      ping: { status: 200, body: { url: "https://example.com" } },
+    },
+  });
+
+  assert.equal(valid.ok, true);
+  assert.equal(valid.dryRun.output.read, 'https://example.com');
+});
+
+test('automations_create supports concise verbose false responses', async () => {
+  const createTool = automationTools.find((tool) => tool.name === 'automations_create');
+  const result = await createTool.handler({
+    id: 'automation-compact-response',
+    name: 'Compact response automation',
+    verbose: false,
+    triggers: [{ id: 'trigger-compact-response', kind: 'event', source: 'test', event: 'compact' }],
+    workflowText: `export default workflow({
+  trigger: event("test.compact"),
+  cells: [code("ok", async () => ({ ok: true }))]
+})`,
+  });
+  const text = result.content[0].text;
+  const payload = JSON.parse(text.slice(text.indexOf('{')));
+
+  assert.equal(payload.id, 'automation-compact-response');
+  assert.equal(payload.triggers[0].id, 'trigger-compact-response');
+  assert.equal(payload.triggers[0].ref, 'test.compact');
+  assert.equal(payload.workflow.id, payload.workflowIds[0]);
+  assert.equal(payload.workflow.workflowText, undefined);
+});
+
+test('automations tools list actions and compact run_now output', async () => {
+  const listActionsTool = automationTools.find((tool) => tool.name === 'automations_list_actions');
+  const runNowTool = automationTools.find((tool) => tool.name === 'automations_run_now');
+
+  const listResult = await listActionsTool.handler({ query: 'yahoo' });
+  const listPayload = JSON.parse(listResult.content[0].text);
+  assert.equal(listPayload.actions.some((action) => action.ref === 'codex.yahoo_stock_price.run'), true);
+
+  const runResult = await runNowTool.handler({
+    automation_id: 'automation-dotted-toolbox',
+    verbose: false,
+  });
+  const text = runResult.content[0].text;
+  const payload = JSON.parse(text.slice(text.indexOf('{')));
+  assert.equal(payload.status, 'completed');
+  assert.deepEqual(payload.outputKeys, ['quote']);
+  assert.equal(payload.output, undefined);
+  assert.equal(payload.cellSummaries[0].name, 'quote');
+});

package/runtime/scripts/amalgm-mcp/tests/events-matcher.test.js

@@ -6,6 +6,7 @@ const assert = require('node:assert/strict');
 const {
   computeSignature,
   extractSignature,
+  matchAllBySignature,
   matchBySignature,
 } = require('../events/matcher');
 
@@ -43,3 +44,25 @@ test('event matcher rejects disabled triggers and wrong secrets', () => {
 
   assert.equal(matchBySignature([trigger(), trigger({ id: 'disabled', enabled: false })], signature, rawBody), null);
 });
+
+test('event matcher filters by source and event when provided', () => {
+  const rawBody = JSON.stringify({ ok: true });
+  const signature = extractSignature({
+    'x-webhook-signature': computeSignature('super-secret', rawBody),
+  });
+
+  const matches = matchAllBySignature([
+    trigger({ id: 'push-main', source: 'github', event: 'push' }),
+    trigger({ id: 'issue-opened', source: 'github', event: 'issues' }),
+    trigger({ id: 'wildcard', source: 'github', event: '*' }),
+  ], signature, rawBody, { source: 'github', event: 'push' });
+
+  assert.deepEqual(matches.map((item) => item.id), ['push-main', 'wildcard']);
+  assert.equal(
+    matchBySignature([trigger({ source: 'github', event: 'issues' })], signature, rawBody, {
+      source: 'github',
+      event: 'push',
+    }),
+    null,
+  );
+});

package/runtime/scripts/amalgm-mcp/tests/workflows-store-runner.test.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-workflows-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+
+const { closeLocalDb } = require('../state/db');
+const { loadEventTriggers, saveEventTriggers } = require('../events/store');
+const { listEventRuns } = require('../events/store');
+const { createWorkflow } = require('../workflows/store');
+const { executeEventWorkflow } = require('../workflows/runner');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('event trigger can run a linked standalone workflow', async () => {
+  const workflow = createWorkflow({
+    id: 'workflow-publish',
+    name: 'Publish workflow',
+    workflowText: `export default workflow({
+  trigger: event("github.push"),
+  cells: [
+    code("filter_push", async ({ payload }) => {
+      return { sha: payload.after }
+    })
+  ]
+})`,
+  });
+
+  saveEventTriggers({
+    version: 2,
+    triggers: [{
+      id: 'trigger-github-push',
+      name: 'GitHub push',
+      source: 'github',
+      event: 'push',
+      enabled: true,
+      secret: 'secret',
+      workflowIds: [workflow.id],
+      createdAt: '2026-05-23T00:00:00.000Z',
+    }],
+  });
+
+  const trigger = loadEventTriggers().triggers.find((item) => item.id === 'trigger-github-push');
+  assert.deepEqual(trigger.workflowIds, ['workflow-publish']);
+
+  await executeEventWorkflow(trigger, {
+    source: 'github',
+    event: 'push',
+    payload: { after: 'abc123' },
+    headers: {},
+    timestamp: '2026-05-23T00:00:01.000Z',
+  });
+
+  const [run] = listEventRuns({ triggerId: trigger.id });
+  assert.equal(run.status, 'completed');
+  assert.equal(run.workflowId, 'workflow-publish');
+  assert.equal(run.workflowName, 'Publish workflow');
+  assert.equal(run.output.filter_push.sha, 'abc123');
+});

package/runtime/scripts/amalgm-mcp/toolbox/tools.js

@@ -12,8 +12,20 @@ const {
   upsertTool,
   upsertToolAction,
 } = require('./store');
+const { toolboxMcpToolName } = require('./runner');
 
-function compactTool(tool, actionCount) {
+function compactAction(action) {
+  return {
+    id: action.id,
+    name: action.name,
+    ref: `${action.toolId}.${action.name}`,
+    status: action.status,
+    description: action.description,
+    mcpToolName: toolboxMcpToolName(action),
+  };
+}
+
+function compactTool(tool, actions) {
   return {
     id: tool.id,
     name: tool.name,
@@ -22,7 +34,8 @@ function compactTool(tool, actionCount) {
     origin: tool.origin,
     status: tool.status,
     discovery: tool.discovery,
-    actionCount,
+    actions: actions.map(compactAction),
+    actionCount: actions.length,
     source: tool.source,
     guide: tool.guide,
     display: tool.display,
@@ -43,7 +56,7 @@ function listPayload(args = {}) {
     .filter((tool) => !args.type || tool.type === args.type)
     .filter((tool) => !args.owner || tool.owner === args.owner)
     .filter((tool) => !args.origin || tool.origin === args.origin)
-    .map((tool) => compactTool(tool, actionsByTool.get(tool.id)?.length || 0));
+    .map((tool) => compactTool(tool, actionsByTool.get(tool.id) || []));
 
   const payload = {
     version: toolbox.version,