amalgm 0.1.51 → 0.1.53

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

@@ -0,0 +1,613 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const { spawn } = require('child_process');
+const vm = require('vm');
+
+const { DEFAULT_CWD } = require('../config');
+const { compileWorkflowText } = require('../workflows/compiler');
+const { callToolboxMcpTool, toolboxMcpToolName } = require('../toolbox/runner');
+const { buildWorkflowInput } = require('./context');
+const { resolveAmalgmCoreTool, resolveToolboxAction, suggestWorkflowToolActions } = require('./tool-actions');
+const {
+  getAutomation,
+  getAutomationByTriggerId,
+  recordAutomationRun,
+  recordWorkflowCellRun,
+} = require('./store');
+
+const DEFAULT_CELL_TIMEOUT_MS = 120_000;
+const DEFAULT_CODE_TIMEOUT_MS = 15_000;
+const MAX_OUTPUT_BYTES = 512 * 1024;
+const runQueues = new Map();
+
+class WorkflowStop extends Error {
+  constructor(message = 'Workflow stopped') {
+    super(message);
+    this.name = 'WorkflowStop';
+  }
+}
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isFunctionRef(value) {
+  return isObject(value) && typeof value.$fn === 'string';
+}
+
+function durationSince(startedAt) {
+  return Date.now() - new Date(startedAt).getTime();
+}
+
+function positiveInteger(value, fallback = null) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.max(1, Math.floor(number));
+}
+
+function queueLimitValue(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return 0;
+  return Math.max(0, Math.floor(number));
+}
+
+function withTimeout(promise, timeoutMs, label) {
+  let timer = null;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    }),
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
+function publicTrigger(trigger) {
+  return {
+    id: trigger.id,
+    automationId: trigger.automationId,
+    name: trigger.name,
+    kind: trigger.kind,
+    source: trigger.source,
+    event: trigger.event,
+    schedule: trigger.schedule,
+  };
+}
+
+function publicWorkflow(workflow) {
+  return {
+    id: workflow.id,
+    name: workflow.name,
+  };
+}
+
+function publicAutomation(automation) {
+  return {
+    id: automation.id,
+    name: automation.name,
+  };
+}
+
+function buildSecrets(allowlist = {}) {
+  const names = Array.isArray(allowlist.secrets) ? allowlist.secrets : [];
+  const secrets = {};
+  for (const name of names) {
+    const key = String(name || '').trim();
+    if (key && process.env[key] != null) secrets[key] = process.env[key];
+  }
+  return secrets;
+}
+
+async function runFunctionSource(fnSource, input, options = {}) {
+  const timeoutMs = Number(options.timeoutMs) || DEFAULT_CODE_TIMEOUT_MS;
+  const sandbox = {
+    __input: input,
+    __result: undefined,
+    console,
+    fetch: globalThis.fetch,
+    URL,
+    URLSearchParams,
+    TextDecoder,
+    TextEncoder,
+    setTimeout,
+    clearTimeout,
+  };
+  const context = vm.createContext(sandbox, {
+    name: 'amalgm-automation-cell',
+    codeGeneration: { strings: false, wasm: false },
+  });
+  const script = new vm.Script(`__result = (${fnSource})(__input)`, {
+    filename: 'automation-workflow-cell.js',
+  });
+
+  try {
+    const result = script.runInContext(context, { timeout: Math.min(timeoutMs, 1000) });
+    if (result && typeof result.then === 'function') {
+      return await withTimeout(result, timeoutMs, 'Workflow function');
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof WorkflowStop || error?.name === 'WorkflowStop') throw error;
+    throw new Error(error?.message || String(error));
+  }
+}
+
+async function resolveDynamic(value, input, options = {}) {
+  if (isFunctionRef(value)) return runFunctionSource(value.$fn, input, options);
+  if (Array.isArray(value)) {
+    const next = [];
+    for (const item of value) next.push(await resolveDynamic(item, input, options));
+    return next;
+  }
+  if (isObject(value)) {
+    const next = {};
+    for (const [key, child] of Object.entries(value)) {
+      next[key] = await resolveDynamic(child, input, options);
+    }
+    return next;
+  }
+  return value;
+}
+
+function appendBuffer(current, chunk) {
+  const next = Buffer.concat([current, Buffer.from(chunk)]);
+  return next.length > MAX_OUTPUT_BYTES ? next.subarray(next.length - MAX_OUTPUT_BYTES) : next;
+}
+
+function safeEnv(extraEnv, allowlist = {}) {
+  const env = {};
+  for (const key of ['PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL', 'LANG', 'LC_ALL', 'TERM', 'TMPDIR']) {
+    if (process.env[key]) env[key] = process.env[key];
+  }
+  for (const key of Array.isArray(allowlist.secrets) ? allowlist.secrets : []) {
+    if (process.env[key] != null) env[key] = process.env[key];
+  }
+  if (isObject(extraEnv)) {
+    for (const [key, value] of Object.entries(extraEnv)) {
+      if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && value != null) env[key] = String(value);
+    }
+  }
+  return env;
+}
+
+async function runShellCommand(config, allowlist) {
+  const command = String(config.command || config.run || '').trim();
+  if (!command) throw new Error('CLI cell needs a command.');
+  if (allowlist.localCompute !== true) {
+    throw new Error('CLI cells require allowlist.localCompute=true.');
+  }
+
+  const timeoutMs = Number(config.timeoutMs || config.timeout_ms) || DEFAULT_CELL_TIMEOUT_MS;
+  const cwd = config.cwd || DEFAULT_CWD;
+  if (!fs.existsSync(cwd)) fs.mkdirSync(cwd, { recursive: true });
+  const child = spawn(command, {
+    cwd,
+    env: safeEnv(config.env, allowlist),
+    shell: true,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+
+  if (config.stdin != null) child.stdin.end(String(config.stdin));
+  else child.stdin.end();
+
+  let stdout = Buffer.alloc(0);
+  let stderr = Buffer.alloc(0);
+  let timedOut = false;
+  const result = await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => {
+        try { child.kill('SIGKILL'); } catch {}
+      }, 1500).unref?.();
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => { stdout = appendBuffer(stdout, chunk); });
+    child.stderr.on('data', (chunk) => { stderr = appendBuffer(stderr, chunk); });
+    child.on('error', (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+      resolve({
+        exitCode: code,
+        signal,
+        timedOut,
+        stdout: stdout.toString('utf8'),
+        stderr: stderr.toString('utf8'),
+      });
+    });
+  });
+
+  if (result.timedOut || result.exitCode !== 0) {
+    const status = result.timedOut ? 'timed out' : `failed with exit code ${result.exitCode ?? result.signal ?? 'unknown'}`;
+    throw new Error([
+      `Command ${status}: ${command}`,
+      result.stdout ? `stdout:\n${result.stdout.trim()}` : null,
+      result.stderr ? `stderr:\n${result.stderr.trim()}` : null,
+    ].filter(Boolean).join('\n\n'));
+  }
+
+  return {
+    command,
+    cwd,
+    exitCode: result.exitCode,
+    stdout: result.stdout,
+    stderr: result.stderr,
+  };
+}
+
+async function runHttpTool(args) {
+  const method = String(args.method || 'GET').toUpperCase();
+  if (!args.url) throw new Error('http.fetch needs a url.');
+  const response = await fetch(args.url, {
+    method,
+    headers: args.headers || {},
+    body: ['GET', 'HEAD'].includes(method) ? undefined : (
+      typeof args.body === 'string' ? args.body : JSON.stringify(args.body ?? {})
+    ),
+  });
+  const text = await response.text();
+  let body = text;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    // Keep raw text.
+  }
+  if (!response.ok) throw new Error(`HTTP ${response.status} ${response.statusText}: ${text.slice(0, 12000)}`);
+  return {
+    status: response.status,
+    headers: Object.fromEntries(response.headers.entries()),
+    body,
+  };
+}
+
+function mcpResultToOutput(result, actionKey) {
+  if (!result) throw new Error(`Tool action returned no result: ${actionKey}.`);
+  if (result.isError) {
+    const text = result.content?.map((part) => part.text).filter(Boolean).join('\n') || `${actionKey} failed.`;
+    throw new Error(text);
+  }
+  return result.structuredContent ?? {
+    text: result.content?.map((part) => part.text).filter(Boolean).join('\n') || '',
+  };
+}
+
+async function runToolCell(cell, args, allowlist) {
+  const actionKey = `${cell.toolId}.${cell.actionName}`;
+  const allowedActions = Array.isArray(allowlist.actions) ? allowlist.actions : [];
+  if (allowedActions.length > 0 && !allowedActions.includes(actionKey)) {
+    throw new Error(`Workflow is not allowed to call ${actionKey}.`);
+  }
+
+  if (cell.toolId === 'http' && cell.actionName === 'fetch') {
+    if (allowlist.network !== true) throw new Error('http.fetch requires allowlist.network=true.');
+    return runHttpTool(args);
+  }
+
+  if (cell.toolId === 'amalgm') {
+    const coreTool = resolveAmalgmCoreTool(cell.actionName);
+    if (!coreTool?.handler) throw new Error(`Amalgm action not found: ${cell.actionName}.`);
+    const result = await coreTool.handler(args, {
+      workflow: true,
+      sessionMetadata: {
+        origin: 'automation-workflow',
+      },
+    });
+    return mcpResultToOutput(result, actionKey);
+  }
+
+  const resolved = resolveToolboxAction(cell.toolId, cell.actionName);
+  if (!resolved) {
+    const suggestions = suggestWorkflowToolActions(cell.toolId, cell.actionName);
+    throw new Error([
+      `Tool action not found: ${actionKey}.`,
+      suggestions.length > 0 ? `Did you mean: ${suggestions.join(', ')}?` : 'Use automations_list_actions to inspect callable workflow actions.',
+    ].join(' '));
+  }
+
+  const result = await callToolboxMcpTool(toolboxMcpToolName(resolved.action), args, {
+    sessionMetadata: {
+      tools: {
+        mode: 'selected',
+        selectedToolIds: [resolved.tool.id, resolved.action.id],
+      },
+    },
+  });
+  return mcpResultToOutput(result, actionKey);
+}
+
+function workflowIrForAutomation(automation) {
+  const workflow = automation.workflow || automation.workflows?.[0];
+  if (!workflow) throw new Error('Automation has no workflow.');
+  if (workflow.workflowIr && workflow.workflowIr.version === 1) return workflow.workflowIr;
+  if (workflow.workflowText || workflow.workflow) return compileWorkflowText(workflow.workflowText || workflow.workflow);
+  throw new Error('Automation workflow has no script.');
+}
+
+async function executeWorkflowCell(cell, ctx, allowlist, limits) {
+  const timeoutMs = Number(cell.timeoutMs || limits.cellTimeoutMs) || DEFAULT_CELL_TIMEOUT_MS;
+  const stop = () => {
+    throw new WorkflowStop();
+  };
+  const input = buildWorkflowInput(ctx, stop);
+
+  if (cell.if !== undefined) {
+    const condition = await resolveDynamic(cell.if, input, { timeoutMs });
+    if (!condition) return { skipped: true, output: null };
+  }
+
+  if (cell.kind === 'code') {
+    const output = await runFunctionSource(cell.code, input, {
+      timeoutMs: Number(cell.timeoutMs || limits.codeTimeoutMs) || DEFAULT_CODE_TIMEOUT_MS,
+    });
+    return { output };
+  }
+
+  if (cell.kind === 'cli') {
+    const config = await resolveDynamic(cell.config || {}, input, { timeoutMs });
+    const output = await runShellCommand(config, allowlist);
+    return { output };
+  }
+
+  if (cell.kind === 'tool') {
+    const args = await resolveDynamic(cell.args || {}, input, { timeoutMs });
+    const output = await runToolCell(cell, args, allowlist);
+    return { output };
+  }
+
+  throw new Error(`Unsupported workflow cell kind "${cell.kind}".`);
+}
+
+async function runAutomationNow(automation, trigger, eventObj = {}) {
+  if (!automation) throw new Error('Automation is required.');
+  if (automation.enabled === false) throw new Error(`Automation "${automation.name}" is disabled.`);
+  const workflow = automation.workflow || automation.workflows?.[0];
+  if (!workflow) throw new Error(`Automation "${automation.name}" has no workflow.`);
+  if (workflow.enabled === false) throw new Error(`Workflow "${workflow.name}" is disabled.`);
+
+  const runId = crypto.randomUUID();
+  const startedAt = new Date().toISOString();
+  const resolvedTrigger = trigger || automation.triggers?.[0] || {
+    id: null,
+    name: 'Manual run',
+    kind: 'manual',
+    automationId: automation.id,
+  };
+  const ir = workflowIrForAutomation(automation);
+  const allowlist = {
+    ...(ir.allowlist || {}),
+    ...(workflow.allowlist || {}),
+  };
+  const limits = {
+    ...(ir.limits || {}),
+    ...(workflow.limits || {}),
+  };
+  const ctx = {
+    automation: publicAutomation(automation),
+    event: eventObj,
+    trigger: publicTrigger(resolvedTrigger),
+    workflow: publicWorkflow(workflow),
+    previous: null,
+    outputs: {},
+    secrets: buildSecrets(allowlist),
+  };
+  const projectPath = workflow.projectPath || automation.projectPath || resolvedTrigger.projectPath || null;
+
+  let run = recordAutomationRun(automation.id, {
+    runId,
+    automationId: automation.id,
+    automationName: automation.name,
+    triggerId: resolvedTrigger.id,
+    triggerName: resolvedTrigger.name,
+    workflowId: workflow.id,
+    workflowName: workflow.name,
+    startedAt,
+    status: 'running',
+    projectPath,
+    workflow: {
+      id: workflow.id,
+      name: workflow.name,
+      version: ir.version,
+      cells: ir.cells.map((cell) => ({ name: cell.name, kind: cell.kind })),
+    },
+  }, { source: 'automation_runs:workflow:start' });
+
+  let status = 'completed';
+  try {
+    for (const cell of ir.cells) {
+      const cellStartedAt = new Date().toISOString();
+      recordAutomationRun(automation.id, {
+        runId,
+        automationId: automation.id,
+        triggerId: resolvedTrigger.id,
+        workflowId: workflow.id,
+        status: 'running',
+        cell: { name: cell.name, kind: cell.kind, status: 'running', startedAt: cellStartedAt },
+      }, { source: 'automation_runs:workflow:cell-start' });
+      recordWorkflowCellRun(run, {
+        name: cell.name,
+        kind: cell.kind,
+        status: 'running',
+        startedAt: cellStartedAt,
+      }, { source: 'workflow_cell_runs:start' });
+
+      try {
+        const result = await executeWorkflowCell(cell, ctx, allowlist, limits);
+        const cellStatus = result.skipped ? 'skipped' : 'completed';
+        if (!result.skipped) {
+          ctx.previous = result.output;
+          ctx.outputs[cell.name] = result.output;
+        }
+        const finishedAt = new Date().toISOString();
+        const cellResult = {
+          name: cell.name,
+          kind: cell.kind,
+          status: cellStatus,
+          startedAt: cellStartedAt,
+          finishedAt,
+          durationMs: durationSince(cellStartedAt),
+          output: result.output,
+        };
+        recordAutomationRun(automation.id, {
+          runId,
+          automationId: automation.id,
+          triggerId: resolvedTrigger.id,
+          workflowId: workflow.id,
+          status: 'running',
+          cell: cellResult,
+        }, { source: 'automation_runs:workflow:cell-complete' });
+        recordWorkflowCellRun(run, cellResult, { source: 'workflow_cell_runs:complete' });
+      } catch (error) {
+        const stopped = error instanceof WorkflowStop || error?.name === 'WorkflowStop';
+        const cellStatus = stopped ? 'stopped' : 'failed';
+        if (stopped) status = 'stopped';
+        const finishedAt = new Date().toISOString();
+        const cellResult = {
+          name: cell.name,
+          kind: cell.kind,
+          status: cellStatus,
+          startedAt: cellStartedAt,
+          finishedAt,
+          durationMs: durationSince(cellStartedAt),
+          error: stopped ? null : (error.message || String(error)),
+        };
+        recordAutomationRun(automation.id, {
+          runId,
+          automationId: automation.id,
+          triggerId: resolvedTrigger.id,
+          workflowId: workflow.id,
+          status: stopped ? status : 'failed',
+          cell: cellResult,
+        }, { source: stopped ? 'automation_runs:workflow:cell-stopped' : 'automation_runs:workflow:cell-failed' });
+        recordWorkflowCellRun(run, cellResult, { source: stopped ? 'workflow_cell_runs:stopped' : 'workflow_cell_runs:failed' });
+        if (stopped) break;
+        throw error;
+      }
+    }
+
+    run = recordAutomationRun(automation.id, {
+      runId,
+      automationId: automation.id,
+      automationName: automation.name,
+      triggerId: resolvedTrigger.id,
+      triggerName: resolvedTrigger.name,
+      workflowId: workflow.id,
+      workflowName: workflow.name,
+      finishedAt: new Date().toISOString(),
+      status,
+      durationMs: durationSince(startedAt),
+      output: ctx.outputs,
+    }, { source: `automation_runs:workflow:${status}` });
+    return run;
+  } catch (error) {
+    recordAutomationRun(automation.id, {
+      runId,
+      automationId: automation.id,
+      automationName: automation.name,
+      triggerId: resolvedTrigger.id,
+      triggerName: resolvedTrigger.name,
+      workflowId: workflow.id,
+      workflowName: workflow.name,
+      finishedAt: new Date().toISOString(),
+      status: 'failed',
+      error: error.message || String(error),
+      durationMs: durationSince(startedAt),
+    }, { source: 'automation_runs:workflow:failed' });
+    throw error;
+  }
+}
+
+function runQueuedAutomation(key, state, item) {
+  state.active += 1;
+  runAutomationNow(item.automation, item.trigger, item.eventObj)
+    .then(item.resolve, item.reject)
+    .finally(() => {
+      state.active = Math.max(0, state.active - 1);
+      const next = state.queue.shift();
+      if (next) {
+        runQueuedAutomation(key, state, next);
+      } else if (state.active === 0) {
+        runQueues.delete(key);
+      }
+    });
+}
+
+function executeAutomation(automation, trigger, eventObj = {}) {
+  const ir = workflowIrForAutomation(automation);
+  const workflow = automation.workflow || automation.workflows?.[0];
+  const limits = {
+    ...(ir.limits || {}),
+    ...(workflow?.limits || {}),
+  };
+  const maxConcurrentRuns = positiveInteger(limits.maxConcurrentRuns);
+  if (!maxConcurrentRuns) return runAutomationNow(automation, trigger, eventObj);
+
+  const key = automation.id;
+  let state = runQueues.get(key);
+  if (!state) {
+    state = { active: 0, queue: [] };
+    runQueues.set(key, state);
+  }
+
+  return new Promise((resolve, reject) => {
+    const item = { automation, trigger, eventObj, resolve, reject };
+    if (state.active < maxConcurrentRuns) {
+      runQueuedAutomation(key, state, item);
+      return;
+    }
+
+    const queueLimit = queueLimitValue(limits.queueLimit);
+    if (state.queue.length >= queueLimit) {
+      const timestamp = new Date().toISOString();
+      const error = new Error(`Automation queue is full for "${automation.name || automation.id}" (${queueLimit} queued).`);
+      recordAutomationRun(automation.id, {
+        runId: crypto.randomUUID(),
+        automationId: automation.id,
+        automationName: automation.name,
+        triggerId: trigger?.id || null,
+        triggerName: trigger?.name || null,
+        workflowId: workflow?.id || null,
+        workflowName: workflow?.name || null,
+        startedAt: timestamp,
+        finishedAt: timestamp,
+        status: 'rejected',
+        projectPath: workflow?.projectPath || automation.projectPath || null,
+        error: error.message,
+      }, { source: 'automation_runs:workflow:queue-full' });
+      reject(error);
+      return;
+    }
+
+    state.queue.push(item);
+  });
+}
+
+function executeAutomationById(automationId, eventObj = {}, opts = {}) {
+  const automation = getAutomation(automationId);
+  if (!automation) return Promise.reject(new Error(`Automation not found: ${automationId}`));
+  const trigger = opts.triggerId
+    ? automation.triggers.find((item) => item.id === opts.triggerId)
+    : automation.triggers[0];
+  return executeAutomation(automation, trigger, eventObj);
+}
+
+function executeAutomationForTrigger(triggerId, eventObj = {}) {
+  const automation = getAutomationByTriggerId(triggerId);
+  if (!automation) return Promise.reject(new Error(`Trigger not found: ${triggerId}`));
+  const trigger = automation.triggers.find((item) => item.id === triggerId);
+  if (!trigger) return Promise.reject(new Error(`Trigger not found: ${triggerId}`));
+  return executeAutomation(automation, trigger, eventObj);
+}
+
+module.exports = {
+  executeAutomation,
+  executeAutomationById,
+  executeAutomationForTrigger,
+  runFunctionSource,
+};

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

@@ -0,0 +1,90 @@
+'use strict';
+
+/**
+ * Automation scheduler.
+ *
+ * Scheduled delivery is now just one trigger kind. The scheduler claims due
+ * scheduled triggers from the unified automation store and runs their
+ * workflows; it does not wake an agent unless the workflow explicitly calls
+ * an agent/tool cell.
+ */
+
+const { SCHEDULER_INTERVAL_MS } = require('../config');
+const { claimDueScheduledTriggers } = require('./store');
+const { executeAutomation } = require('./runner');
+
+let schedulerTimer = null;
+let isPolling = false;
+
+const schedulerStatus = {
+  startedAt: null,
+  lastTickAt: null,
+  lastError: null,
+  lastClaimed: 0,
+};
+
+function startAutomationScheduler() {
+  console.log(`[AmalgmMCP:Automations] Starting scheduler (interval: ${SCHEDULER_INTERVAL_MS}ms)`);
+  if (schedulerTimer) clearInterval(schedulerTimer);
+  schedulerStatus.startedAt = new Date().toISOString();
+  pollAutomationScheduler();
+  schedulerTimer = setInterval(pollAutomationScheduler, SCHEDULER_INTERVAL_MS);
+}
+
+function pollAutomationScheduler() {
+  if (isPolling) return;
+  isPolling = true;
+  try {
+    const now = new Date();
+    schedulerStatus.lastTickAt = now.toISOString();
+    const claims = claimDueScheduledTriggers(now, { source: 'automation-scheduler' });
+    schedulerStatus.lastClaimed = claims.length;
+    schedulerStatus.lastError = null;
+
+    for (const claim of claims) {
+      if (!claim?.automation || !claim?.trigger) continue;
+      executeAutomation(claim.automation, claim.trigger, {
+        id: claim.scheduledFor || now.toISOString(),
+        source: 'amalgm.scheduler',
+        event: 'scheduled',
+        payload: {
+          scheduledFor: claim.scheduledFor,
+          triggerId: claim.trigger.id,
+          automationId: claim.automation.id,
+        },
+        headers: {},
+        receivedAt: now.toISOString(),
+      }).catch((error) => {
+        console.error(`[AmalgmMCP:Automations] Automation ${claim.automation.id} failed:`, error.message);
+      });
+    }
+  } catch (error) {
+    schedulerStatus.lastError = error.message || String(error);
+    console.error('[AmalgmMCP:Automations] Scheduler poll error:', schedulerStatus.lastError);
+  } finally {
+    isPolling = false;
+  }
+}
+
+function getAutomationSchedulerStatus() {
+  return {
+    intervalMs: SCHEDULER_INTERVAL_MS,
+    running: Boolean(schedulerTimer),
+    polling: isPolling,
+    ...schedulerStatus,
+  };
+}
+
+function stopAutomationScheduler() {
+  if (schedulerTimer) {
+    clearInterval(schedulerTimer);
+    schedulerTimer = null;
+  }
+}
+
+module.exports = {
+  getAutomationSchedulerStatus,
+  pollAutomationScheduler,
+  startAutomationScheduler,
+  stopAutomationScheduler,
+};