amalgm 0.1.51 → 0.1.52

package/runtime/scripts/amalgm-mcp/automations/tool-actions.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const { readToolbox } = require('../toolbox/store');
+const { toolboxMcpToolName } = require('../toolbox/runner');
+
+function coreTools() {
+  return [
+    ...require('../notify'),
+    ...require('../agents/tools'),
+    ...require('../apps/tools'),
+  ];
+}
+
+function actionKey(toolId, actionName) {
+  return `${toolId}.${actionName}`;
+}
+
+function normalizeRef(value) {
+  return String(value || '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '');
+}
+
+function isRunnableToolboxTool(tool) {
+  return !!tool
+    && tool.status === 'enabled'
+    && tool.origin !== 'system'
+    && (tool.type === 'cli' || tool.type === 'api');
+}
+
+function resolveAmalgmCoreTool(actionName) {
+  const normalized = String(actionName || '').trim();
+  return coreTools().find((tool) => (
+    tool.name === normalized
+    || tool.name === normalized.replace(/\./g, '_')
+  )) || null;
+}
+
+function resolveToolboxAction(toolId, actionName) {
+  const normalizedToolId = String(toolId || '').trim();
+  const normalizedActionName = String(actionName || '').trim();
+  const toolbox = readToolbox();
+  const action = Object.values(toolbox.toolActions || {}).find((candidate) => {
+    if (candidate.toolId !== normalizedToolId) return false;
+    return candidate.name === normalizedActionName
+      || candidate.id === normalizedActionName
+      || candidate.id === `${normalizedToolId}.${normalizedActionName}`
+      || candidate.id === `${normalizedToolId}:${normalizedActionName}`;
+  });
+  if (!action || action.status !== 'enabled') return null;
+  const tool = toolbox.tools?.[action.toolId];
+  return isRunnableToolboxTool(tool) ? { tool, action } : null;
+}
+
+function resolveWorkflowToolAction(toolId, actionName) {
+  const normalizedToolId = String(toolId || '').trim();
+  const normalizedActionName = String(actionName || '').trim();
+  if (normalizedToolId === 'http' && normalizedActionName === 'fetch') {
+    return {
+      kind: 'builtin',
+      ref: 'http.fetch',
+      toolId: 'http',
+      actionName: 'fetch',
+      description: 'Fetch a URL from a workflow; requires allowlist.network=true at runtime.',
+    };
+  }
+  if (normalizedToolId === 'amalgm') {
+    const tool = resolveAmalgmCoreTool(normalizedActionName);
+    if (!tool) return null;
+    return {
+      kind: 'amalgm',
+      ref: actionKey('amalgm', tool.name),
+      toolId: 'amalgm',
+      actionName: tool.name,
+      tool,
+    };
+  }
+  const resolved = resolveToolboxAction(normalizedToolId, normalizedActionName);
+  if (!resolved) return null;
+  return {
+    kind: 'toolbox',
+    ref: actionKey(resolved.tool.id, resolved.action.name),
+    toolId: resolved.tool.id,
+    actionName: resolved.action.name,
+    tool: resolved.tool,
+    action: resolved.action,
+  };
+}
+
+function workflowActionSummaries() {
+  const toolbox = readToolbox();
+  const actions = [{
+    ref: 'http.fetch',
+    id: 'http.fetch',
+    toolId: 'http',
+    actionName: 'fetch',
+    kind: 'builtin',
+    description: 'Fetch a URL; requires allowlist.network=true.',
+  }];
+
+  for (const tool of coreTools()) {
+    actions.push({
+      ref: actionKey('amalgm', tool.name),
+      id: actionKey('amalgm', tool.name),
+      toolId: 'amalgm',
+      actionName: tool.name,
+      kind: 'amalgm',
+      description: tool.description || '',
+    });
+  }
+
+  for (const action of Object.values(toolbox.toolActions || {})) {
+    const tool = toolbox.tools?.[action.toolId];
+    if (!isRunnableToolboxTool(tool) || action.status !== 'enabled') continue;
+    actions.push({
+      ref: actionKey(tool.id, action.name),
+      id: action.id,
+      toolId: tool.id,
+      actionName: action.name,
+      kind: 'toolbox',
+      toolName: tool.name,
+      toolType: tool.type,
+      description: action.description || '',
+      mcpToolName: toolboxMcpToolName(action),
+    });
+  }
+
+  return actions.sort((a, b) => a.ref.localeCompare(b.ref));
+}
+
+function suggestWorkflowToolActions(toolId, actionName, limit = 5) {
+  const needle = normalizeRef(actionKey(toolId, actionName));
+  const actionNameNeedle = normalizeRef(actionName);
+  const scored = workflowActionSummaries().map((action) => {
+    const ref = normalizeRef(action.ref);
+    const id = normalizeRef(action.id);
+    const mcpName = normalizeRef(action.mcpToolName);
+    let score = 0;
+    if (ref === needle || id === needle || mcpName === needle) score += 100;
+    if (ref.includes(needle) || id.includes(needle) || mcpName.includes(needle)) score += 40;
+    if (needle.includes(ref) || needle.includes(id) || (mcpName && needle.includes(mcpName))) score += 30;
+    if (actionNameNeedle && ref.includes(actionNameNeedle)) score += 10;
+    return { action, score };
+  }).filter((item) => item.score > 0);
+  const list = scored.length > 0
+    ? scored.sort((a, b) => b.score - a.score)
+    : workflowActionSummaries().map((action) => ({ action, score: 0 }));
+  return list.slice(0, limit).map((item) => item.action.ref);
+}
+
+function validateWorkflowToolActions(ir) {
+  const errors = [];
+  for (const cell of Array.isArray(ir?.cells) ? ir.cells : []) {
+    if (cell.kind !== 'tool') continue;
+    if (resolveWorkflowToolAction(cell.toolId, cell.actionName)) continue;
+    const ref = actionKey(cell.toolId, cell.actionName);
+    const suggestions = suggestWorkflowToolActions(cell.toolId, cell.actionName);
+    errors.push({
+      phase: 'static',
+      cell: cell.name,
+      toolId: cell.toolId,
+      actionName: cell.actionName,
+      message: [
+        `Tool action "${ref}" was not found.`,
+        suggestions.length > 0 ? `Did you mean: ${suggestions.join(', ')}?` : 'Use automations_list_actions to inspect callable workflow actions.',
+      ].join(' '),
+    });
+  }
+  return errors;
+}
+
+module.exports = {
+  resolveAmalgmCoreTool,
+  resolveToolboxAction,
+  resolveWorkflowToolAction,
+  suggestWorkflowToolActions,
+  validateWorkflowToolActions,
+  workflowActionSummaries,
+};

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

@@ -0,0 +1,418 @@
+'use strict';
+
+const { textResult, errorResult } = require('../lib/tool-result');
+const {
+  createAutomation,
+  deleteAutomation,
+  getAutomation,
+  listAutomationRuns,
+  listAutomations,
+  updateAutomation,
+} = require('./store');
+const { executeAutomationById } = require('./runner');
+const { validateWorkflowText } = require('./validator');
+const { workflowActionSummaries } = require('./tool-actions');
+
+const TRIGGER_DESCRIPTION = [
+  'Automation triggers. `kind="event"` creates a webhook trigger with source/event matching and returns a webhook URL + secret. Event refs are `source.event`, for example `github.push`; empty source/event becomes `*`.',
+  '`kind="scheduled"` creates a local scheduled trigger with a `schedule` object: `{ kind: "cron", expr, tz }`, `{ kind: "once", at }`, or `{ kind: "interval", ms }`.',
+  'For a manual-only automation, still create one trigger with `enabled: false`; `automations_run_now` can run the workflow without waiting for that trigger to fire.',
+].join('\n\n');
+
+const WORKFLOW_DESCRIPTION = [
+  'Source-of-truth workflow script. Use `export default workflow({ trigger, allowlist, limits, cells })`.',
+  'The script is the workflow. A trigger decides when it runs; cells decide what happens.',
+  'Workflow `trigger` refs are `source.event` strings such as `github.push`; `github.*` means any GitHub event; `*.push` means a push from any source; `*.*` means any source and event.',
+  'Cells can call `code(name, fn)`, gated local `cli(name, config)`, gated `http(name, config)`, and `tool(name, "tool.action", args)`.',
+  'Agents are tools too: use `agent(name, agentIdOrName, { prompt, run_in_background: true })` or `tool(name, "amalgm.talk_to_agent", args)`.',
+  'Every function receives one ctx object: `{ automation, trigger, workflow, event, payload, headers, previous, outputs, cells, secrets, stop }`.',
+  'Cell outputs are available as `ctx.cells.cellName.output`, `ctx.cells.cellName.field` for object outputs, `ctx.outputs.cellName`, and top-level `ctx.cellName`.',
+  'Example: `tool("notify", "amalgm.notify_user", ({ cells }) => ({ message: cells.greet.output.message }))`.',
+].join('\n\n');
+
+function compactAutomation(automation, includeWorkflowText = true) {
+  return {
+    id: automation.id,
+    name: automation.name,
+    description: automation.description,
+    enabled: automation.enabled,
+    status: automation.status,
+    projectPath: automation.projectPath,
+    triggerIds: automation.triggerIds,
+    workflowIds: automation.workflowIds,
+    triggers: automation.triggers,
+    workflows: automation.workflows.map((workflow) => ({
+      ...workflow,
+      ...(includeWorkflowText ? {} : { workflowText: undefined }),
+    })),
+    createdAt: automation.createdAt,
+    updatedAt: automation.updatedAt,
+  };
+}
+
+function summarizeTrigger(trigger) {
+  return {
+    id: trigger.id,
+    kind: trigger.kind,
+    name: trigger.name,
+    enabled: trigger.enabled,
+    status: trigger.status,
+    ...(trigger.kind === 'scheduled' ? {
+      schedule: trigger.schedule,
+      nextRunAt: trigger.nextRunAt,
+    } : {
+      source: trigger.source,
+      event: trigger.event,
+      ref: `${trigger.source || '*'}.${trigger.event || '*'}`,
+      webhookUrl: trigger.webhookUrl,
+      secret: trigger.secret,
+    }),
+  };
+}
+
+function summarizeWorkflow(workflow) {
+  if (!workflow) return null;
+  return {
+    id: workflow.id,
+    name: workflow.name,
+    enabled: workflow.enabled,
+    status: workflow.status,
+    ...(workflow.compilerErrors?.length ? { compilerErrors: workflow.compilerErrors } : {}),
+  };
+}
+
+function summarizeAutomation(automation) {
+  return {
+    id: automation.id,
+    name: automation.name,
+    enabled: automation.enabled,
+    status: automation.status,
+    triggerIds: automation.triggerIds,
+    workflowIds: automation.workflowIds,
+    triggers: automation.triggers.map(summarizeTrigger),
+    workflow: summarizeWorkflow(automation.workflow || automation.workflows?.[0]),
+    updatedAt: automation.updatedAt,
+  };
+}
+
+function automationResponse(automation, { verbose = true, includeWorkflowText = true } = {}) {
+  return verbose
+    ? compactAutomation(automation, includeWorkflowText)
+    : summarizeAutomation(automation);
+}
+
+function parseBoolean(value, fallback) {
+  return typeof value === 'boolean' ? value : fallback;
+}
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function summarizeRun(run) {
+  const cellsByName = new Map();
+  for (const event of Array.isArray(run?.events) ? run.events : []) {
+    if (!event.cell?.name) continue;
+    cellsByName.set(event.cell.name, {
+      name: event.cell.name,
+      kind: event.cell.kind,
+      status: event.cell.status,
+      durationMs: event.cell.durationMs,
+      error: event.cell.error || undefined,
+    });
+  }
+  return {
+    id: run.id,
+    runId: run.runId || run.id,
+    automationId: run.automationId,
+    automationName: run.automationName,
+    triggerId: run.triggerId,
+    triggerName: run.triggerName,
+    workflowId: run.workflowId,
+    workflowName: run.workflowName,
+    status: run.status,
+    startedAt: run.startedAt,
+    finishedAt: run.finishedAt,
+    durationMs: run.durationMs,
+    error: run.error,
+    cellSummaries: Array.from(cellsByName.values()),
+    outputKeys: isObject(run.output) ? Object.keys(run.output) : [],
+  };
+}
+
+module.exports = [
+  {
+    name: 'automations_validate',
+    description:
+      'Validate a workflow script before saving it. Compiles the single workflow script and, by default, does a dry run that executes code cells but does not call external tools, HTTP, or CLI commands. Use this before automations_create/update when authoring non-trivial workflows.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        workflowText: { type: 'string', description: WORKFLOW_DESCRIPTION },
+        workflow: { type: 'string', description: 'Alias for workflowText.' },
+        dry_run: { type: 'boolean', description: 'If false, only compile. Defaults to true.' },
+        execute_code: { type: 'boolean', description: 'If false, code cells are not executed during dry run. Defaults to true.' },
+        event: {
+          type: 'object',
+          description: 'Optional fake event for dry run.',
+          properties: {
+            source: { type: 'string' },
+            event: { type: 'string' },
+            payload: { type: 'object' },
+            headers: { type: 'object' },
+          },
+        },
+        mock_outputs: {
+          type: 'object',
+          description: 'Optional per-cell mock outputs, keyed by cell name. Use this when a downstream cell consumes output from a dry-run-stubbed tool/http/cli cell.',
+        },
+      },
+    },
+    async handler(input = {}) {
+      try {
+        const validation = await validateWorkflowText(input.workflowText || input.workflow, input);
+        return textResult(JSON.stringify(validation, null, 2));
+      } catch (error) {
+        return errorResult(error.message || String(error));
+      }
+    },
+  },
+  {
+    name: 'automations_list_actions',
+    description:
+      'List workflow-callable tool actions for automation scripts. Use these refs in workflow cells like `tool("name", "tool.ref", args)`. This includes built-in `http.fetch`, Amalgm actions such as `amalgm.notify_user`, and runnable Toolbox CLI/API actions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Optional case-insensitive filter across ref, id, name, and description.' },
+        kind: { type: 'string', enum: ['builtin', 'amalgm', 'toolbox'], description: 'Optional action kind filter.' },
+      },
+    },
+    async handler({ query, kind } = {}) {
+      try {
+        const cleanQuery = typeof query === 'string' ? query.trim().toLowerCase() : '';
+        const actions = workflowActionSummaries()
+          .filter((action) => !kind || action.kind === kind)
+          .filter((action) => {
+            if (!cleanQuery) return true;
+            return [
+              action.ref,
+              action.id,
+              action.toolId,
+              action.actionName,
+              action.toolName,
+              action.description,
+              action.mcpToolName,
+            ].some((value) => String(value || '').toLowerCase().includes(cleanQuery));
+          });
+        return textResult(JSON.stringify({ actions }, null, 2));
+      } catch (error) {
+        return errorResult(error.message || String(error));
+      }
+    },
+  },
+  {
+    name: 'automations_create',
+    description:
+      'Create a local Automation. An automation is one or more triggers plus one workflow. It is stored on the user computer in the Local Live SQLite store and runs locally. Scheduled/event triggers do not wake an agent unless the workflow explicitly calls an agent/tool.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Optional stable automation id. Usually omit this.' },
+        name: { type: 'string', description: 'Human-readable automation name.' },
+        description: { type: 'string', description: 'Optional markdown description.' },
+        enabled: { type: 'boolean', description: 'Whether the automation starts active.' },
+        projectPath: { type: 'string', description: 'Default project/workspace path used by workflow cells.' },
+        triggers: {
+          type: 'array',
+          description: TRIGGER_DESCRIPTION,
+          items: {
+            type: 'object',
+            properties: {
+              kind: { type: 'string', enum: ['event', 'webhook', 'scheduled'] },
+              name: { type: 'string' },
+              description: { type: 'string' },
+              enabled: { type: 'boolean' },
+              source: { type: 'string', description: 'Event/webhook source label, e.g. github. Empty means any source.' },
+              event: { type: 'string', description: 'Event/webhook event label, e.g. push. Empty means any event.' },
+              sourceUrl: { type: 'string', description: 'Optional display URL for source identity/favicon.' },
+              schedule: {
+                type: 'object',
+                description: 'Scheduled trigger config for kind=scheduled.',
+                properties: {
+                  kind: { type: 'string', enum: ['cron', 'once', 'interval'] },
+                  expr: { type: 'string' },
+                  tz: { type: 'string' },
+                  at: { type: 'string' },
+                  ms: { type: 'number' },
+                },
+              },
+            },
+          },
+        },
+        workflowText: { type: 'string', description: WORKFLOW_DESCRIPTION },
+        workflow: { type: 'string', description: 'Alias for workflowText.' },
+        allowlist: { type: 'object', description: 'Workflow permissions: localCompute, network, secrets, actions.' },
+        limits: { type: 'object', description: 'Workflow limits: maxConcurrentRuns, queueLimit, cellTimeoutMs, codeTimeoutMs.' },
+        verbose: { type: 'boolean', description: 'Set false for a concise response with ids, status, triggers, webhook URL/secret, and workflow summary. Defaults to true.' },
+      },
+      required: ['name', 'triggers'],
+    },
+    async handler(input = {}) {
+      try {
+        const workflowText = input.workflowText || input.workflow;
+        if (typeof workflowText !== 'string' || !workflowText.trim()) {
+          return errorResult('workflowText or workflow is required.');
+        }
+        const automation = createAutomation({
+          ...input,
+          workflowText,
+        }, { source: 'automations_create' });
+        return textResult(`Automation created.\n\n${JSON.stringify(automationResponse(automation, {
+          verbose: input.verbose !== false,
+        }), null, 2)}`);
+      } catch (error) {
+        return errorResult(error.message || String(error));
+      }
+    },
+  },
+  {
+    name: 'automations_list',
+    description: 'List local automations with their triggers, workflow summary, webhook URLs, secrets, schedules, and status.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enabled_only: { type: 'boolean', description: 'If true, only return enabled automations.' },
+        include_workflow_text: { type: 'boolean', description: 'If false, omit workflow source text from the listing.' },
+        verbose: { type: 'boolean', description: 'Set false for concise automation summaries. Defaults to true.' },
+      },
+    },
+    async handler({ enabled_only, include_workflow_text, verbose } = {}) {
+      try {
+        let automations = listAutomations();
+        if (enabled_only) automations = automations.filter((automation) => automation.enabled !== false);
+        const includeWorkflowText = parseBoolean(include_workflow_text, false);
+        if (automations.length === 0) return textResult('No automations found.');
+        return textResult(JSON.stringify({
+          automations: automations.map((automation) => automationResponse(automation, {
+            verbose: verbose !== false,
+            includeWorkflowText,
+          })),
+        }, null, 2));
+      } catch (error) {
+        return errorResult(error.message || String(error));
+      }
+    },
+  },
+  {
+    name: 'automations_get',
+    description: 'Get one local automation by id, including all triggers, workflow source, compiled IR, and recent runs.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        automation_id: { type: 'string' },
+        include_runs: { type: 'boolean', description: 'Include recent run history. Defaults to true.' },
+        verbose: { type: 'boolean', description: 'Set false for a concise automation summary. Defaults to true.' },
+      },
+      required: ['automation_id'],
+    },
+    async handler({ automation_id, include_runs, verbose } = {}) {
+      try {
+        const automation = getAutomation(automation_id);
+        if (!automation) return errorResult(`Automation not found: ${automation_id}`);
+        const runs = include_runs === false ? undefined : listAutomationRuns({ automationId: automation.id, limit: 20 });
+        return textResult(JSON.stringify({
+          automation: automationResponse(automation, { verbose: verbose !== false }),
+          ...(runs ? { runs } : {}),
+        }, null, 2));
+      } catch (error) {
+        return errorResult(error.message || String(error));
+      }
+    },
+  },
+  {
+    name: 'automations_update',
+    description:
+      'Update a local automation. You can edit metadata, enabled state, replace triggers, or update the workflow source/allowlist/limits. The next trigger firing uses the updated workflow.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        automation_id: { type: 'string' },
+        name: { type: 'string' },
+        description: { type: 'string' },
+        enabled: { type: 'boolean' },
+        projectPath: { type: 'string' },
+        triggers: { type: 'array', description: TRIGGER_DESCRIPTION },
+        workflowText: { type: 'string', description: WORKFLOW_DESCRIPTION },
+        workflow: { type: 'string', description: 'Alias for workflowText.' },
+        allowlist: { type: 'object' },
+        limits: { type: 'object' },
+        verbose: { type: 'boolean', description: 'Set false for a concise response. Defaults to true.' },
+      },
+      required: ['automation_id'],
+    },
+    async handler({ automation_id, workflow, verbose, ...updates } = {}) {
+      try {
+        const automation = updateAutomation(automation_id, {
+          ...updates,
+          ...(workflow !== undefined && updates.workflowText === undefined ? { workflowText: workflow } : {}),
+        }, { source: 'automations_update' });
+        return textResult(`Automation updated.\n\n${JSON.stringify(automationResponse(automation, {
+          verbose: verbose !== false,
+        }), null, 2)}`);
+      } catch (error) {
+        return errorResult(error.message || String(error));
+      }
+    },
+  },
+  {
+    name: 'automations_delete',
+    description: 'Delete a local automation, including its triggers and workflow if no other automation uses that workflow.',
+    inputSchema: {
+      type: 'object',
+      properties: { automation_id: { type: 'string' } },
+      required: ['automation_id'],
+    },
+    async handler({ automation_id } = {}) {
+      try {
+        const deleted = deleteAutomation(automation_id, { source: 'automations_delete' });
+        return textResult(`Automation "${deleted.name}" deleted.`);
+      } catch (error) {
+        return errorResult(error.message || String(error));
+      }
+    },
+  },
+  {
+    name: 'automations_run_now',
+    description: 'Run an automation workflow immediately, outside its configured triggers. This works for manual-only automations that use a disabled trigger.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        automation_id: { type: 'string' },
+        trigger_id: { type: 'string', description: 'Optional trigger context to use for the run.' },
+        payload: { type: 'object', description: 'Optional payload exposed to workflow cells as event.payload.' },
+        verbose: { type: 'boolean', description: 'Set false for a concise run summary. Defaults to true.' },
+      },
+      required: ['automation_id'],
+    },
+    async handler({ automation_id, trigger_id, payload, verbose } = {}) {
+      try {
+        const run = await executeAutomationById(automation_id, {
+          id: `manual:${Date.now()}`,
+          source: 'amalgm.manual',
+          event: 'run_now',
+          payload: payload || {},
+          headers: {},
+          receivedAt: new Date().toISOString(),
+        }, { triggerId: trigger_id });
+        return textResult(`Automation run started.\n\n${JSON.stringify(
+          verbose === false ? summarizeRun(run) : run,
+          null,
+          2,
+        )}`);
+      } catch (error) {
+        return errorResult(error.message || String(error));
+      }
+    },
+  },
+];