amalgm 0.1.51 → 0.1.52

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

@@ -0,0 +1,1125 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const { loadCronParser } = require('../deps');
+const { openLocalDb } = require('../state/db');
+const { appendStateEvent, insertStateEvent, publishStateEvent } = require('../state/events');
+const { normalizeTaskSchedule } = require('../tasks/schedule-normalization');
+const { compileWorkflowText, splitEventRef } = require('../workflows/compiler');
+const { getWebhookUrl } = require('../events/webhook-url');
+const { validateCellReferences } = require('./cell-references');
+const { validateWorkflowToolActions } = require('./tool-actions');
+
+const LEGACY_MIGRATION_KEY = 'automations_legacy_migrated_v1';
+const DEFAULT_RUN_LIMIT = 100;
+
+let cronParser = null;
+
+function cron() {
+  if (!cronParser) cronParser = loadCronParser();
+  return cronParser;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function parseJson(value, fallback = null) {
+  if (typeof value !== 'string' || !value) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+function stringifyJson(value, fallback) {
+  return JSON.stringify(value === undefined ? fallback : value);
+}
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function cleanString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function isoOrNull(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+function validDate(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function metaValue(db, key) {
+  return db.prepare('SELECT value FROM local_meta WHERE key = ?').get(key)?.value || null;
+}
+
+function setMetaValue(db, key, value) {
+  db.prepare(`
+    INSERT INTO local_meta (key, value, updated_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(key) DO UPDATE SET
+      value = excluded.value,
+      updated_at = excluded.updated_at
+  `).run(key, value, nowIso());
+}
+
+function defaultWorkflowText(label = 'Automation', triggerRef = 'automation.manual') {
+  const safeLabel = JSON.stringify(label || 'Automation');
+  return `export default workflow({
+  trigger: event(${JSON.stringify(triggerRef)}),
+  cells: [
+    code("start", async () => ({
+      ok: true,
+      message: ${safeLabel} + " has no workflow steps configured yet."
+    }))
+  ]
+})`;
+}
+
+function workflowTriggerRefForInput(input = {}) {
+  const firstTrigger = Array.isArray(input.triggers) ? input.triggers[0] : input.trigger;
+  if (firstTrigger?.kind === 'scheduled') return 'scheduled.run';
+  if (firstTrigger?.source || firstTrigger?.event || input.source || input.event) {
+    const source = cleanString(firstTrigger?.source || input.source) || '*';
+    const event = cleanString(firstTrigger?.event || input.event) || '*';
+    return `${source}.${event}`;
+  }
+  return 'automation.manual';
+}
+
+function normalizeWorkflowRecord(input = {}, existing = null) {
+  const timestamp = nowIso();
+  const workflowText = cleanString(
+    input.workflowText ?? input.workflow ?? existing?.workflowText,
+  ) || defaultWorkflowText(input.name || existing?.name || 'Automation', workflowTriggerRefForInput(input));
+  let workflowIr = isObject(input.workflowIr)
+    ? input.workflowIr
+    : isObject(existing?.workflowIr)
+      ? existing.workflowIr
+      : null;
+  let compilerErrors = null;
+
+  try {
+    workflowIr = compileWorkflowText(workflowText);
+    const staticErrors = [
+      ...validateCellReferences(workflowIr),
+      ...validateWorkflowToolActions(workflowIr),
+    ];
+    if (staticErrors.length > 0) {
+      throw new Error(staticErrors.map((item) => item.message).join('\n'));
+    }
+  } catch (error) {
+    workflowIr = null;
+    compilerErrors = [error.message || String(error)];
+  }
+
+  return {
+    id: cleanString(input.id) || existing?.id || crypto.randomUUID(),
+    name: cleanString(input.name) || existing?.name || 'Untitled workflow',
+    description: input.description ?? existing?.description ?? '',
+    enabled: input.enabled ?? existing?.enabled ?? true,
+    projectPath: input.projectPath ?? existing?.projectPath ?? null,
+    workflowText,
+    workflowIr,
+    compilerErrors,
+    allowlist: isObject(input.allowlist) ? input.allowlist : existing?.allowlist || {},
+    limits: isObject(input.limits) ? input.limits : existing?.limits || {},
+    internal: input.internal ?? existing?.internal ?? false,
+    createdAt: isoOrNull(input.createdAt) || existing?.createdAt || timestamp,
+    updatedAt: existing ? timestamp : (isoOrNull(input.updatedAt) || null),
+  };
+}
+
+function workflowRowParams(workflow) {
+  return {
+    id: workflow.id,
+    name: workflow.name,
+    description: workflow.description || '',
+    enabled: workflow.enabled === false ? 0 : 1,
+    project_path: workflow.projectPath || null,
+    workflow_text: workflow.workflowText || '',
+    workflow_ir_json: workflow.workflowIr ? JSON.stringify(workflow.workflowIr) : null,
+    compiler_errors_json: workflow.compilerErrors ? JSON.stringify(workflow.compilerErrors) : null,
+    allowlist_json: stringifyJson(workflow.allowlist, {}),
+    limits_json: stringifyJson(workflow.limits, {}),
+    created_at: workflow.createdAt || nowIso(),
+    updated_at: workflow.updatedAt || workflow.createdAt || nowIso(),
+    workflow_json: JSON.stringify(workflow),
+  };
+}
+
+function rowToWorkflow(row) {
+  if (!row) return null;
+  const parsed = parseJson(row.workflow_json, {});
+  return normalizeWorkflowRecord({
+    ...parsed,
+    id: row.id,
+    name: row.name,
+    description: row.description || '',
+    enabled: row.enabled === 1,
+    projectPath: row.project_path || null,
+    workflowText: row.workflow_text || parsed.workflowText,
+    workflowIr: parseJson(row.workflow_ir_json, parsed.workflowIr || null),
+    compilerErrors: parseJson(row.compiler_errors_json, parsed.compilerErrors || null),
+    allowlist: parseJson(row.allowlist_json, parsed.allowlist || {}),
+    limits: parseJson(row.limits_json, parsed.limits || {}),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  });
+}
+
+function upsertWorkflowRow(db, workflow) {
+  const params = workflowRowParams(workflow);
+  db.prepare(`
+    INSERT INTO automation_workflows (
+      id, name, description, enabled, project_path, workflow_text,
+      workflow_ir_json, compiler_errors_json, allowlist_json, limits_json,
+      created_at, updated_at, workflow_json
+    )
+    VALUES (
+      @id, @name, @description, @enabled, @project_path, @workflow_text,
+      @workflow_ir_json, @compiler_errors_json, @allowlist_json, @limits_json,
+      @created_at, @updated_at, @workflow_json
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      name = excluded.name,
+      description = excluded.description,
+      enabled = excluded.enabled,
+      project_path = excluded.project_path,
+      workflow_text = excluded.workflow_text,
+      workflow_ir_json = excluded.workflow_ir_json,
+      compiler_errors_json = excluded.compiler_errors_json,
+      allowlist_json = excluded.allowlist_json,
+      limits_json = excluded.limits_json,
+      updated_at = excluded.updated_at,
+      workflow_json = excluded.workflow_json
+  `).run(params);
+}
+
+function normalizeSchedule(inputSchedule, existingSchedule = null) {
+  const candidate = inputSchedule || existingSchedule;
+  const result = normalizeTaskSchedule(candidate);
+  if (result.error) throw new Error(result.error);
+  return result.schedule;
+}
+
+function computeNextRunAt(trigger, afterDate = new Date()) {
+  if (!trigger || trigger.enabled === false || trigger.kind !== 'scheduled') return null;
+  const schedule = trigger.schedule;
+  if (!schedule) return null;
+  const after = validDate(afterDate) || new Date();
+
+  if (schedule.kind === 'once') {
+    const at = validDate(schedule.at);
+    if (!at) return null;
+    if (trigger.lastFiredAt && validDate(trigger.lastFiredAt) >= at) return null;
+    return at > after ? at.toISOString() : at.toISOString();
+  }
+
+  if (schedule.kind === 'interval') {
+    const ms = Number(schedule.ms);
+    if (!Number.isFinite(ms) || ms < 60_000) return null;
+    return new Date(after.getTime() + ms).toISOString();
+  }
+
+  if (schedule.kind === 'cron') {
+    try {
+      const interval = cron().CronExpressionParser.parse(schedule.expr, {
+        currentDate: after,
+        tz: schedule.tz || 'UTC',
+      });
+      return interval.next().toDate().toISOString();
+    } catch {
+      return null;
+    }
+  }
+
+  return null;
+}
+
+function scheduleLabel(schedule) {
+  if (!schedule) return null;
+  if (schedule.kind === 'once') return schedule.at || 'Once';
+  if (schedule.kind === 'interval') {
+    const ms = Number(schedule.ms);
+    if (!Number.isFinite(ms)) return 'Interval';
+    if (ms >= 86_400_000) return `Every ${Math.round(ms / 86_400_000)}d`;
+    if (ms >= 3_600_000) return `Every ${Math.round(ms / 3_600_000)}h`;
+    return `Every ${Math.max(1, Math.round(ms / 60_000))}m`;
+  }
+  if (schedule.kind === 'cron') return schedule.expr || 'Cron';
+  return null;
+}
+
+function normalizeTriggerRecord(input = {}, automation, existing = null) {
+  const timestamp = nowIso();
+  const rawKind = cleanString(input.kind || existing?.kind || 'event').toLowerCase();
+  const kind = rawKind === 'webhook' ? 'event' : rawKind;
+  if (!['event', 'scheduled'].includes(kind)) {
+    throw new Error(`Unsupported trigger kind: ${rawKind}`);
+  }
+
+  const trigger = {
+    id: cleanString(input.id) || existing?.id || crypto.randomUUID(),
+    automationId: automation.id,
+    workflowId: automation.workflowId,
+    kind,
+    name: cleanString(input.name) || existing?.name || automation.name || 'Automation trigger',
+    description: input.description ?? existing?.description ?? '',
+    enabled: input.enabled ?? existing?.enabled ?? automation.enabled !== false,
+    projectPath: input.projectPath ?? existing?.projectPath ?? automation.projectPath ?? null,
+    createdAt: isoOrNull(input.createdAt) || existing?.createdAt || timestamp,
+    updatedAt: existing ? timestamp : (isoOrNull(input.updatedAt) || null),
+    lastFiredAt: isoOrNull(input.lastFiredAt) || existing?.lastFiredAt || null,
+  };
+
+  if (kind === 'scheduled') {
+    trigger.schedule = normalizeSchedule(input.schedule, existing?.schedule);
+    trigger.scheduleLabel = scheduleLabel(trigger.schedule);
+    trigger.nextRunAt = input.nextRunAt === null
+      ? null
+      : isoOrNull(input.nextRunAt) || existing?.nextRunAt || computeNextRunAt(trigger, trigger.createdAt);
+    trigger.source = null;
+    trigger.event = null;
+    trigger.sourceUrl = null;
+    trigger.webhookUrl = null;
+    trigger.secret = null;
+  } else {
+    const irTrigger = automation.workflow?.workflowIr?.trigger || {};
+    const source = cleanString(input.source ?? existing?.source ?? irTrigger.source) || '*';
+    const event = cleanString(input.event ?? input.eventName ?? existing?.event ?? irTrigger.event) || '*';
+    trigger.source = source;
+    trigger.event = event;
+    trigger.sourceUrl = input.sourceUrl ?? existing?.sourceUrl ?? null;
+    trigger.webhookUrl = input.webhookUrl || existing?.webhookUrl || getWebhookUrl();
+    trigger.secret = input.secret || existing?.secret || crypto.randomUUID().replace(/-/g, '');
+    trigger.schedule = null;
+    trigger.scheduleLabel = null;
+    trigger.nextRunAt = null;
+  }
+
+  return trigger;
+}
+
+function triggerRowParams(trigger) {
+  return {
+    id: trigger.id,
+    automation_id: trigger.automationId,
+    kind: trigger.kind,
+    name: trigger.name,
+    description: trigger.description || '',
+    enabled: trigger.enabled === false ? 0 : 1,
+    schedule_kind: trigger.schedule?.kind || null,
+    schedule_json: trigger.schedule ? JSON.stringify(trigger.schedule) : null,
+    next_run_at: trigger.nextRunAt || null,
+    last_fired_at: trigger.lastFiredAt || null,
+    source: trigger.source || null,
+    event: trigger.event || null,
+    source_url: trigger.sourceUrl || null,
+    webhook_url: trigger.webhookUrl || null,
+    secret: trigger.secret || null,
+    created_at: trigger.createdAt || nowIso(),
+    updated_at: trigger.updatedAt || trigger.createdAt || nowIso(),
+    trigger_json: JSON.stringify(trigger),
+  };
+}
+
+function rowToTrigger(row) {
+  if (!row) return null;
+  const parsed = parseJson(row.trigger_json, {});
+  return {
+    ...parsed,
+    id: row.id,
+    automationId: row.automation_id,
+    workflowId: parsed.workflowId || null,
+    kind: row.kind,
+    name: row.name,
+    description: row.description || '',
+    enabled: row.enabled === 1,
+    schedule: parseJson(row.schedule_json, parsed.schedule || null),
+    scheduleLabel: parsed.scheduleLabel || scheduleLabel(parseJson(row.schedule_json, parsed.schedule || null)),
+    nextRunAt: row.next_run_at || null,
+    lastFiredAt: row.last_fired_at || null,
+    source: row.source || null,
+    event: row.event || null,
+    sourceUrl: row.source_url || null,
+    webhookUrl: row.webhook_url || null,
+    secret: row.secret || null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function upsertTriggerRow(db, trigger) {
+  const params = triggerRowParams(trigger);
+  db.prepare(`
+    INSERT INTO automation_triggers (
+      id, automation_id, kind, name, description, enabled, schedule_kind,
+      schedule_json, next_run_at, last_fired_at, source, event, source_url,
+      webhook_url, secret, created_at, updated_at, trigger_json
+    )
+    VALUES (
+      @id, @automation_id, @kind, @name, @description, @enabled, @schedule_kind,
+      @schedule_json, @next_run_at, @last_fired_at, @source, @event, @source_url,
+      @webhook_url, @secret, @created_at, @updated_at, @trigger_json
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      automation_id = excluded.automation_id,
+      kind = excluded.kind,
+      name = excluded.name,
+      description = excluded.description,
+      enabled = excluded.enabled,
+      schedule_kind = excluded.schedule_kind,
+      schedule_json = excluded.schedule_json,
+      next_run_at = excluded.next_run_at,
+      last_fired_at = excluded.last_fired_at,
+      source = excluded.source,
+      event = excluded.event,
+      source_url = excluded.source_url,
+      webhook_url = excluded.webhook_url,
+      secret = excluded.secret,
+      updated_at = excluded.updated_at,
+      trigger_json = excluded.trigger_json
+  `).run(params);
+}
+
+function normalizeAutomationRecord(input = {}, workflow, existing = null) {
+  const timestamp = nowIso();
+  return {
+    id: cleanString(input.id) || existing?.id || crypto.randomUUID(),
+    name: cleanString(input.name) || existing?.name || workflow?.name || 'Untitled automation',
+    description: input.description ?? existing?.description ?? workflow?.description ?? '',
+    enabled: input.enabled ?? existing?.enabled ?? true,
+    projectPath: input.projectPath ?? existing?.projectPath ?? workflow?.projectPath ?? null,
+    workflowId: workflow.id,
+    createdAt: isoOrNull(input.createdAt) || existing?.createdAt || timestamp,
+    updatedAt: existing ? timestamp : (isoOrNull(input.updatedAt) || null),
+  };
+}
+
+function automationRowParams(automation) {
+  return {
+    id: automation.id,
+    name: automation.name,
+    description: automation.description || '',
+    enabled: automation.enabled === false ? 0 : 1,
+    project_path: automation.projectPath || null,
+    workflow_id: automation.workflowId,
+    created_at: automation.createdAt || nowIso(),
+    updated_at: automation.updatedAt || automation.createdAt || nowIso(),
+    automation_json: JSON.stringify(automation),
+  };
+}
+
+function rowToAutomationBase(row) {
+  if (!row) return null;
+  const parsed = parseJson(row.automation_json, {});
+  return {
+    ...parsed,
+    id: row.id,
+    name: row.name,
+    description: row.description || '',
+    enabled: row.enabled === 1,
+    projectPath: row.project_path || null,
+    workflowId: row.workflow_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function upsertAutomationRow(db, automation) {
+  const params = automationRowParams(automation);
+  db.prepare(`
+    INSERT INTO automation_definitions (
+      id, name, description, enabled, project_path, workflow_id,
+      created_at, updated_at, automation_json
+    )
+    VALUES (
+      @id, @name, @description, @enabled, @project_path, @workflow_id,
+      @created_at, @updated_at, @automation_json
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      name = excluded.name,
+      description = excluded.description,
+      enabled = excluded.enabled,
+      project_path = excluded.project_path,
+      workflow_id = excluded.workflow_id,
+      updated_at = excluded.updated_at,
+      automation_json = excluded.automation_json
+  `).run(params);
+}
+
+function workflowStatus(workflow) {
+  if (!workflow || workflow.enabled === false) return 'paused';
+  if (Array.isArray(workflow.compilerErrors) && workflow.compilerErrors.length > 0) return 'error';
+  return 'idle';
+}
+
+function triggerStatus(trigger) {
+  if (!trigger || trigger.enabled === false) return 'paused';
+  return 'idle';
+}
+
+function automationStatus(automation, triggers, workflow) {
+  if (automation.enabled === false) return 'paused';
+  if (workflowStatus(workflow) === 'error') return 'error';
+  if (triggers.some((trigger) => triggerStatus(trigger) === 'error')) return 'error';
+  if (triggers.length > 0 && triggers.every((trigger) => trigger.enabled === false)) return 'paused';
+  return 'idle';
+}
+
+function composeAutomation(base, triggers, workflow) {
+  const normalizedTriggers = triggers.map((trigger) => ({
+    ...trigger,
+    workflowId: base.workflowId,
+    workflowIds: [base.workflowId],
+    status: triggerStatus(trigger),
+    backing: {
+      resource: 'triggers',
+      id: trigger.id,
+    },
+  }));
+  const normalizedWorkflow = workflow ? {
+    ...workflow,
+    triggerIds: normalizedTriggers.map((trigger) => trigger.id),
+    automationIds: [base.id],
+    status: workflowStatus(workflow),
+  } : null;
+
+  return {
+    ...base,
+    kind: normalizedTriggers[0]?.kind || 'automation',
+    status: automationStatus(base, normalizedTriggers, normalizedWorkflow),
+    triggerIds: normalizedTriggers.map((trigger) => trigger.id),
+    workflowIds: [base.workflowId],
+    triggers: normalizedTriggers,
+    workflow: normalizedWorkflow,
+    workflows: normalizedWorkflow ? [normalizedWorkflow] : [],
+  };
+}
+
+function readAutomationGraph(db = openLocalDb()) {
+  ensureAutomationsStore();
+  const automationRows = db.prepare('SELECT * FROM automation_definitions ORDER BY datetime(created_at) DESC, lower(name)').all();
+  const workflowRows = db.prepare('SELECT * FROM automation_workflows').all();
+  const triggerRows = db.prepare('SELECT * FROM automation_triggers ORDER BY datetime(created_at) DESC, lower(name)').all();
+
+  const workflowsById = new Map(workflowRows.map((row) => {
+    const workflow = rowToWorkflow(row);
+    return [workflow.id, workflow];
+  }));
+  const triggersByAutomation = new Map();
+  for (const row of triggerRows) {
+    const trigger = rowToTrigger(row);
+    if (!triggersByAutomation.has(trigger.automationId)) triggersByAutomation.set(trigger.automationId, []);
+    triggersByAutomation.get(trigger.automationId).push(trigger);
+  }
+
+  const automations = automationRows
+    .map(rowToAutomationBase)
+    .filter(Boolean)
+    .map((automation) => composeAutomation(
+      automation,
+      triggersByAutomation.get(automation.id) || [],
+      workflowsById.get(automation.workflowId) || null,
+    ));
+  const triggers = automations.flatMap((automation) => automation.triggers);
+  const usedWorkflowIds = new Set(automations.map((automation) => automation.workflowId));
+  const workflows = Array.from(workflowsById.values()).map((workflow) => ({
+    ...workflow,
+    triggerIds: triggers.filter((trigger) => trigger.workflowId === workflow.id).map((trigger) => trigger.id),
+    automationIds: automations.filter((automation) => automation.workflowId === workflow.id).map((automation) => automation.id),
+    status: workflowStatus(workflow),
+    orphaned: !usedWorkflowIds.has(workflow.id),
+  }));
+
+  return { automations, triggers, workflows };
+}
+
+function publishResources(source = 'automations:save') {
+  const resources = readAutomationGraph();
+  appendStateEvent({ resource: 'automations', op: 'replace', value: resources.automations, source });
+  appendStateEvent({ resource: 'triggers', op: 'replace', value: resources.triggers, source });
+  appendStateEvent({ resource: 'workflows', op: 'replace', value: resources.workflows, source });
+}
+
+function defaultTriggersForInput(input, automation) {
+  if (Array.isArray(input.triggers) && input.triggers.length > 0) return input.triggers;
+  if (input.trigger && typeof input.trigger === 'object') return [input.trigger];
+  if (input.schedule) {
+    return [{
+      kind: 'scheduled',
+      name: input.name,
+      description: input.description,
+      schedule: input.schedule,
+      enabled: input.enabled,
+      projectPath: input.projectPath,
+    }];
+  }
+  return [{
+    kind: 'event',
+    name: input.name,
+    description: input.description,
+    source: input.source,
+    event: input.event,
+    sourceUrl: input.sourceUrl,
+    enabled: input.enabled,
+    projectPath: input.projectPath,
+  }];
+}
+
+function insertAutomationBundle(db, input = {}) {
+  const workflowInput = {
+    ...(isObject(input.workflow) ? input.workflow : {}),
+    name: input.workflowName || input.name,
+    description: input.workflowDescription ?? input.description,
+    enabled: input.workflowEnabled ?? input.enabled,
+    projectPath: input.workflowProjectPath ?? input.projectPath,
+    workflowText: input.workflowText || (typeof input.workflow === 'string' ? input.workflow : input.workflow?.workflowText),
+    allowlist: input.allowlist || input.workflow?.allowlist,
+    limits: input.limits || input.workflow?.limits,
+  };
+  const workflow = normalizeWorkflowRecord(workflowInput);
+  if (workflow.compilerErrors?.length) throw new Error(workflow.compilerErrors.join('\n'));
+
+  const automation = normalizeAutomationRecord(input, workflow);
+  automation.workflow = workflow;
+  const triggerInputs = defaultTriggersForInput(input, automation);
+  const triggers = triggerInputs.map((triggerInput) => normalizeTriggerRecord(triggerInput, automation));
+  if (triggers.length === 0) throw new Error('Automation requires at least one trigger.');
+
+  upsertWorkflowRow(db, workflow);
+  upsertAutomationRow(db, automation);
+  for (const trigger of triggers) upsertTriggerRow(db, trigger);
+  return composeAutomation(automation, triggers, workflow);
+}
+
+function createAutomation(input = {}, options = {}) {
+  ensureAutomationsStore();
+  let automation = null;
+  const db = openLocalDb();
+  db.transaction(() => {
+    automation = insertAutomationBundle(db, input);
+  })();
+  publishResources(options.source || 'automations:create');
+  return automation;
+}
+
+function getAutomation(automationId) {
+  const id = cleanString(automationId);
+  if (!id) return null;
+  return readAutomationGraph().automations.find((automation) => automation.id === id) || null;
+}
+
+function getAutomationByTriggerId(triggerId) {
+  const id = cleanString(triggerId);
+  if (!id) return null;
+  return readAutomationGraph().automations.find((automation) => (
+    automation.triggers.some((trigger) => trigger.id === id)
+  )) || null;
+}
+
+function updateAutomation(automationId, updates = {}, options = {}) {
+  ensureAutomationsStore();
+  const existing = getAutomation(automationId);
+  if (!existing) throw new Error(`Automation not found: ${automationId}`);
+  let saved = null;
+  const db = openLocalDb();
+
+  db.transaction(() => {
+    const workflow = normalizeWorkflowRecord({
+      ...existing.workflow,
+      ...(isObject(updates.workflow) ? updates.workflow : {}),
+      ...(updates.workflowText !== undefined ? { workflowText: updates.workflowText } : {}),
+      ...(updates.workflow !== undefined && typeof updates.workflow === 'string' ? { workflowText: updates.workflow } : {}),
+      ...(updates.workflowName !== undefined ? { name: updates.workflowName } : {}),
+      ...(updates.allowlist !== undefined ? { allowlist: updates.allowlist } : {}),
+      ...(updates.limits !== undefined ? { limits: updates.limits } : {}),
+    }, existing.workflow);
+    if (workflow.compilerErrors?.length) throw new Error(workflow.compilerErrors.join('\n'));
+
+    const base = normalizeAutomationRecord({
+      ...existing,
+      ...updates,
+      id: existing.id,
+    }, workflow, existing);
+    base.workflow = workflow;
+    upsertWorkflowRow(db, workflow);
+    upsertAutomationRow(db, base);
+
+    let triggers = existing.triggers;
+    if (Array.isArray(updates.triggers)) {
+      db.prepare('DELETE FROM automation_triggers WHERE automation_id = ?').run(existing.id);
+      triggers = updates.triggers.map((triggerInput) => normalizeTriggerRecord(triggerInput, base));
+      for (const trigger of triggers) upsertTriggerRow(db, trigger);
+    } else if (isObject(updates.trigger) || updates.trigger_id || updates.triggerId) {
+      const triggerId = updates.trigger_id || updates.triggerId || updates.trigger?.id;
+      triggers = existing.triggers.map((trigger) => {
+        if (trigger.id !== triggerId) return trigger;
+        const next = normalizeTriggerRecord({
+          ...trigger,
+          ...(updates.trigger || {}),
+          id: trigger.id,
+        }, base, trigger);
+        upsertTriggerRow(db, next);
+        return next;
+      });
+    }
+
+    saved = composeAutomation(base, triggers, workflow);
+  })();
+
+  publishResources(options.source || 'automations:update');
+  return saved;
+}
+
+function updateAutomationByTriggerId(triggerId, updates = {}, options = {}) {
+  const automation = getAutomationByTriggerId(triggerId);
+  if (!automation) throw new Error(`Trigger not found: ${triggerId}`);
+  const {
+    trigger_id: _trigger_id,
+    triggerId: _triggerId,
+    id: _id,
+    kind,
+    name,
+    description,
+    enabled,
+    schedule,
+    source,
+    event,
+    eventName,
+    sourceUrl,
+    projectPath,
+    nextRunAt,
+    webhookUrl,
+    secret,
+    ...automationUpdates
+  } = updates || {};
+  const triggerUpdates = isObject(updates.trigger) ? updates.trigger : {};
+  return updateAutomation(automation.id, {
+    ...automationUpdates,
+    trigger: {
+      ...triggerUpdates,
+      id: triggerId,
+      kind: triggerUpdates.kind ?? kind,
+      name: triggerUpdates.name ?? name,
+      description: triggerUpdates.description ?? description,
+      enabled: triggerUpdates.enabled ?? enabled,
+      schedule: triggerUpdates.schedule ?? schedule,
+      source: triggerUpdates.source ?? source,
+      event: triggerUpdates.event ?? event,
+      eventName: triggerUpdates.eventName ?? eventName,
+      sourceUrl: triggerUpdates.sourceUrl ?? sourceUrl,
+      projectPath: triggerUpdates.projectPath ?? projectPath,
+      nextRunAt: triggerUpdates.nextRunAt ?? nextRunAt,
+      webhookUrl: triggerUpdates.webhookUrl ?? webhookUrl,
+      secret: triggerUpdates.secret ?? secret,
+    },
+  }, options);
+}
+
+function deleteAutomation(automationId, options = {}) {
+  ensureAutomationsStore();
+  const existing = getAutomation(automationId);
+  if (!existing) throw new Error(`Automation not found: ${automationId}`);
+  const db = openLocalDb();
+  db.transaction(() => {
+    db.prepare('DELETE FROM automation_definitions WHERE id = ?').run(existing.id);
+    db.prepare(`
+      DELETE FROM automation_workflows
+      WHERE id = ?
+        AND NOT EXISTS (
+          SELECT 1 FROM automation_definitions WHERE workflow_id = automation_workflows.id
+        )
+    `).run(existing.workflowId);
+  })();
+  publishResources(options.source || 'automations:delete');
+  return existing;
+}
+
+function deleteAutomationByTriggerId(triggerId, options = {}) {
+  const automation = getAutomationByTriggerId(triggerId);
+  if (!automation) throw new Error(`Trigger not found: ${triggerId}`);
+  return deleteAutomation(automation.id, options);
+}
+
+function listAutomations() {
+  return readAutomationGraph().automations;
+}
+
+function listTriggers() {
+  return readAutomationGraph().triggers;
+}
+
+function listWorkflows() {
+  return readAutomationGraph().workflows;
+}
+
+function listEventTriggersForIngress() {
+  return listTriggers().filter((trigger) => trigger.kind === 'event' && trigger.enabled !== false);
+}
+
+function markTriggerFired(triggerId, options = {}) {
+  ensureAutomationsStore();
+  const automation = getAutomationByTriggerId(triggerId);
+  if (!automation) return null;
+  const trigger = automation.triggers.find((item) => item.id === triggerId);
+  if (!trigger) return null;
+  const timestamp = options.firedAt || nowIso();
+  const next = {
+    ...trigger,
+    lastFiredAt: timestamp,
+    updatedAt: timestamp,
+  };
+  if (next.kind === 'scheduled') {
+    if (next.schedule?.kind === 'once') next.enabled = false;
+    next.nextRunAt = next.enabled === false ? null : computeNextRunAt(next, timestamp);
+  }
+  openLocalDb().transaction(() => {
+    upsertTriggerRow(openLocalDb(), next);
+  })();
+  publishResources(options.source || 'automations:trigger-fired');
+  return next;
+}
+
+function claimDueScheduledTriggers(now = new Date(), options = {}) {
+  ensureAutomationsStore();
+  const db = openLocalDb();
+  const nowDate = validDate(now) || new Date();
+  const timestamp = nowDate.toISOString();
+  const rows = db.prepare(`
+    SELECT automation_triggers.*
+    FROM automation_triggers
+    INNER JOIN automation_definitions
+      ON automation_definitions.id = automation_triggers.automation_id
+    INNER JOIN automation_workflows
+      ON automation_workflows.id = automation_definitions.workflow_id
+    WHERE automation_triggers.kind = 'scheduled'
+      AND automation_triggers.enabled = 1
+      AND automation_definitions.enabled = 1
+      AND automation_workflows.enabled = 1
+      AND automation_triggers.next_run_at IS NOT NULL
+      AND automation_triggers.next_run_at <= ?
+    ORDER BY datetime(automation_triggers.next_run_at) ASC
+  `).all(timestamp);
+
+  const claims = [];
+  db.transaction(() => {
+    for (const row of rows) {
+      const automation = getAutomation(row.automation_id);
+      if (!automation) continue;
+      const trigger = automation.triggers.find((item) => item.id === row.id);
+      if (!trigger) continue;
+      const fired = {
+        ...trigger,
+        lastFiredAt: timestamp,
+        updatedAt: timestamp,
+      };
+      if (fired.schedule?.kind === 'once') fired.enabled = false;
+      fired.nextRunAt = fired.enabled === false ? null : computeNextRunAt(fired, nowDate);
+      upsertTriggerRow(db, fired);
+      claims.push({
+        automation: composeAutomation(
+          automation,
+          automation.triggers.map((item) => (item.id === fired.id ? fired : item)),
+          automation.workflow,
+        ),
+        trigger: fired,
+        scheduledFor: row.next_run_at,
+      });
+    }
+  })();
+
+  if (claims.length > 0) publishResources(options.source || 'automations:scheduler-claim');
+  return claims;
+}
+
+function rowToAutomationRun(row) {
+  if (!row) return null;
+  const parsed = parseJson(row.run_json, {});
+  return {
+    ...parsed,
+    id: row.id,
+    runId: row.id,
+    automationId: row.automation_id,
+    triggerId: row.trigger_id || parsed.triggerId || null,
+    workflowId: row.workflow_id || parsed.workflowId || null,
+    status: row.status,
+    startedAt: row.started_at || parsed.startedAt || null,
+    finishedAt: row.finished_at || parsed.finishedAt || null,
+    projectPath: row.project_path || parsed.projectPath || null,
+    error: row.error || parsed.error || null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function automationRunParams(run) {
+  const timestamp = nowIso();
+  const createdAt = run.createdAt || timestamp;
+  const updatedAt = run.updatedAt || timestamp;
+  const runJson = {
+    ...run,
+    id: run.id,
+    runId: run.id,
+    automationId: run.automationId,
+    triggerId: run.triggerId || null,
+    workflowId: run.workflowId || null,
+    status: run.status || 'running',
+    startedAt: run.startedAt || null,
+    finishedAt: run.finishedAt || null,
+    projectPath: run.projectPath || null,
+    error: run.error || null,
+    createdAt,
+    updatedAt,
+  };
+  return {
+    id: run.id,
+    automation_id: run.automationId,
+    trigger_id: run.triggerId || null,
+    workflow_id: run.workflowId || null,
+    status: run.status || 'running',
+    started_at: run.startedAt || null,
+    finished_at: run.finishedAt || null,
+    project_path: run.projectPath || null,
+    error: run.error || null,
+    run_json: JSON.stringify(runJson),
+    created_at: createdAt,
+    updated_at: updatedAt,
+  };
+}
+
+function upsertAutomationRunRow(db, run) {
+  const params = automationRunParams(run);
+  db.prepare(`
+    INSERT INTO automation_runs (
+      id, automation_id, trigger_id, workflow_id, status, started_at,
+      finished_at, project_path, error, run_json, created_at, updated_at
+    )
+    VALUES (
+      @id, @automation_id, @trigger_id, @workflow_id, @status, @started_at,
+      @finished_at, @project_path, @error, @run_json, @created_at, @updated_at
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      automation_id = excluded.automation_id,
+      trigger_id = excluded.trigger_id,
+      workflow_id = excluded.workflow_id,
+      status = excluded.status,
+      started_at = excluded.started_at,
+      finished_at = excluded.finished_at,
+      project_path = excluded.project_path,
+      error = excluded.error,
+      run_json = excluded.run_json,
+      updated_at = excluded.updated_at
+  `).run(params);
+}
+
+function recordAutomationRun(automationId, entry, options = {}) {
+  if (!automationId || (!entry?.runId && !entry?.id)) return null;
+  ensureAutomationsStore();
+  const db = openLocalDb();
+  const runId = entry.runId || entry.id;
+  let event = null;
+  let run = null;
+  db.transaction(() => {
+    const existing = rowToAutomationRun(db.prepare('SELECT * FROM automation_runs WHERE id = ?').get(runId));
+    const timestamp = nowIso();
+    const events = Array.isArray(existing?.events) ? existing.events.slice(-99) : [];
+    events.push({ ...entry, recordedAt: timestamp });
+    run = {
+      ...(existing || {}),
+      id: runId,
+      automationId,
+      triggerId: entry.triggerId ?? existing?.triggerId ?? null,
+      workflowId: entry.workflowId ?? existing?.workflowId ?? null,
+      automationName: entry.automationName ?? existing?.automationName ?? null,
+      triggerName: entry.triggerName ?? existing?.triggerName ?? null,
+      workflowName: entry.workflowName ?? existing?.workflowName ?? null,
+      status: entry.status || existing?.status || 'running',
+      startedAt: entry.startedAt || existing?.startedAt || timestamp,
+      finishedAt: entry.finishedAt || existing?.finishedAt || null,
+      projectPath: entry.projectPath ?? existing?.projectPath ?? null,
+      error: entry.error || existing?.error || null,
+      output: entry.output !== undefined ? entry.output : existing?.output,
+      events,
+      createdAt: existing?.createdAt || timestamp,
+      updatedAt: timestamp,
+    };
+    upsertAutomationRunRow(db, run);
+    event = insertStateEvent(db, {
+      resource: 'automation_runs',
+      op: existing ? 'update' : 'insert',
+      id: run.id,
+      value: run,
+      source: options.source || 'automation_runs:record',
+    });
+  })();
+  publishStateEvent(event);
+  return run;
+}
+
+function listAutomationRuns(options = {}) {
+  ensureAutomationsStore();
+  const limit = Math.max(1, Math.min(Number(options.limit) || DEFAULT_RUN_LIMIT, 1000));
+  const db = openLocalDb();
+  const rows = options.automationId
+    ? db.prepare(`
+        SELECT * FROM automation_runs
+        WHERE automation_id = ?
+        ORDER BY datetime(updated_at) DESC
+        LIMIT ?
+      `).all(options.automationId, limit)
+    : db.prepare(`
+        SELECT * FROM automation_runs
+        ORDER BY datetime(updated_at) DESC
+        LIMIT ?
+      `).all(limit);
+  return rows.map(rowToAutomationRun).filter(Boolean);
+}
+
+function recordWorkflowCellRun(run, cell, options = {}) {
+  if (!run?.id || !cell?.name) return null;
+  ensureAutomationsStore();
+  const db = openLocalDb();
+  const timestamp = nowIso();
+  const cellRun = {
+    id: `${run.id}:${cell.name}`,
+    runId: run.id,
+    automationId: run.automationId,
+    triggerId: run.triggerId || null,
+    workflowId: run.workflowId || null,
+    cellName: cell.name,
+    cellKind: cell.kind || 'code',
+    status: cell.status || 'running',
+    startedAt: cell.startedAt || timestamp,
+    finishedAt: cell.finishedAt || null,
+    output: cell.output,
+    error: cell.error || null,
+    createdAt: cell.createdAt || timestamp,
+    updatedAt: timestamp,
+  };
+  let event = null;
+  db.transaction(() => {
+    db.prepare(`
+      INSERT INTO workflow_cell_runs (
+        id, run_id, automation_id, trigger_id, workflow_id, cell_name,
+        cell_kind, status, started_at, finished_at, output_json, error,
+        cell_json, created_at, updated_at
+      )
+      VALUES (
+        @id, @run_id, @automation_id, @trigger_id, @workflow_id, @cell_name,
+        @cell_kind, @status, @started_at, @finished_at, @output_json, @error,
+        @cell_json, @created_at, @updated_at
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        status = excluded.status,
+        finished_at = excluded.finished_at,
+        output_json = excluded.output_json,
+        error = excluded.error,
+        cell_json = excluded.cell_json,
+        updated_at = excluded.updated_at
+    `).run({
+      id: cellRun.id,
+      run_id: cellRun.runId,
+      automation_id: cellRun.automationId,
+      trigger_id: cellRun.triggerId,
+      workflow_id: cellRun.workflowId,
+      cell_name: cellRun.cellName,
+      cell_kind: cellRun.cellKind,
+      status: cellRun.status,
+      started_at: cellRun.startedAt,
+      finished_at: cellRun.finishedAt,
+      output_json: cellRun.output === undefined ? null : JSON.stringify(cellRun.output),
+      error: cellRun.error,
+      cell_json: JSON.stringify(cellRun),
+      created_at: cellRun.createdAt,
+      updated_at: cellRun.updatedAt,
+    });
+    event = insertStateEvent(db, {
+      resource: 'workflow_cell_runs',
+      op: 'update',
+      id: cellRun.id,
+      value: cellRun,
+      source: options.source || 'workflow_cell_runs:record',
+    });
+  })();
+  publishStateEvent(event);
+  return cellRun;
+}
+
+function listWorkflowCellRuns(options = {}) {
+  ensureAutomationsStore();
+  const limit = Math.max(1, Math.min(Number(options.limit) || DEFAULT_RUN_LIMIT, 1000));
+  const db = openLocalDb();
+  const rows = options.runId
+    ? db.prepare(`
+        SELECT * FROM workflow_cell_runs
+        WHERE run_id = ?
+        ORDER BY datetime(created_at) ASC
+        LIMIT ?
+      `).all(options.runId, limit)
+    : db.prepare(`
+        SELECT * FROM workflow_cell_runs
+        ORDER BY datetime(updated_at) DESC
+        LIMIT ?
+      `).all(limit);
+  return rows.map((row) => parseJson(row.cell_json, null)).filter(Boolean);
+}
+
+function migrateLegacyAutomations(db) {
+  if (metaValue(db, LEGACY_MIGRATION_KEY)) return;
+  setMetaValue(db, LEGACY_MIGRATION_KEY, nowIso());
+}
+
+let ensuring = false;
+let ensured = false;
+
+function ensureAutomationsStore() {
+  if (ensured || ensuring) return;
+  ensuring = true;
+  try {
+    const db = openLocalDb();
+    migrateLegacyAutomations(db);
+    ensured = true;
+  } finally {
+    ensuring = false;
+  }
+}
+
+function eventRefForTrigger(trigger) {
+  return splitEventRef(`${trigger?.source || '*'}.${trigger?.event || '*'}`);
+}
+
+module.exports = {
+  claimDueScheduledTriggers,
+  createAutomation,
+  defaultWorkflowText,
+  deleteAutomation,
+  deleteAutomationByTriggerId,
+  ensureAutomationsStore,
+  eventRefForTrigger,
+  getAutomation,
+  getAutomationByTriggerId,
+  listAutomationRuns,
+  listAutomations,
+  listEventTriggersForIngress,
+  listTriggers,
+  listWorkflowCellRuns,
+  listWorkflows,
+  markTriggerFired,
+  normalizeWorkflowRecord,
+  publishResources,
+  recordAutomationRun,
+  recordWorkflowCellRun,
+  updateAutomation,
+  updateAutomationByTriggerId,
+};