amalgm 0.1.51 → 0.1.53

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

@@ -1,176 +0,0 @@
-/**
- * Minimal artifact MCP tools.
- *
- * An artifact is a user-hosted production service. We do not scaffold or wrap
- * it; we register the command, keep it alive locally, and expose an artifact
- * DNS route while this computer is connected.
- */
-
-const { textResult, errorResult } = require('../lib/tool-result');
-const { getConnectedRoutes, loadArtifacts } = require('./store');
-const {
-  connectDns,
-  disconnectDns,
-  redeployArtifact,
-  registerArtifact,
-  startArtifact,
-  stopArtifact,
-} = require('./supervisor');
-
-function artifactSummary(artifact) {
-  return [
-    `${artifact.name} (${artifact.id})`,
-    `status: ${artifact.status}`,
-    `cwd: ${artifact.cwd}`,
-    `port: ${artifact.port}`,
-    `dns: ${artifact.dnsConnected ? artifact.publicUrl : 'disconnected'}`,
-    `autostart: ${artifact.autostart !== false}`,
-    `keepAlive: ${artifact.keepAlive !== false}`,
-    artifact.error ? `error: ${artifact.error}` : null,
-  ].filter(Boolean).join('\n');
-}
-
-module.exports = [
-  {
-    name: 'artifacts_register',
-    description:
-      'Register a user-hosted artifact from an existing project on this computer. Artifacts should be production services: prefer passing a build_command such as "npm run build" and a production start_command such as "npm run start -- --host 0.0.0.0 --port {port}" or any command that binds to PORT/{port}. The MCP does not scaffold or enforce a framework; it stores the record in ~/.amalgm, starts it, keeps it alive while the computer is on, and connects it to artifact DNS by default.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'Human-readable artifact name' },
-        cwd: { type: 'string', description: 'Project directory on this computer' },
-        port: { type: 'number', description: 'Port the artifact should bind to. If omitted, one is allocated.' },
-        build_command: { type: 'string', description: 'Optional production build command, run before start/redeploy' },
-        start_command: { type: 'string', description: 'Required production start command. Use {port} or PORT.' },
-        description: { type: 'string' },
-        connect_dns: { type: 'boolean', description: 'Whether to expose through artifact DNS immediately. Defaults true.' },
-        autostart: { type: 'boolean', description: 'Start on Amalgm boot. Defaults true.' },
-        keep_alive: { type: 'boolean', description: 'Restart if the process exits. Defaults true.' },
-      },
-      required: ['start_command'],
-    },
-    async handler(args) {
-      try {
-        const artifact = await registerArtifact(args || {});
-        return textResult(`Artifact registered.\n\n${artifactSummary(artifact)}`);
-      } catch (err) {
-        return errorResult(err.message);
-      }
-    },
-  },
-  {
-    name: 'artifacts_list',
-    description: 'List locally registered artifacts from ~/.amalgm/artifacts.json.',
-    inputSchema: { type: 'object', properties: {} },
-    async handler() {
-      const artifacts = loadArtifacts().artifacts;
-      if (artifacts.length === 0) return textResult('No artifacts registered.');
-      return textResult(artifacts.map(artifactSummary).join('\n\n'));
-    },
-  },
-  {
-    name: 'artifacts_routes',
-    description: 'List artifact DNS routes currently advertised by this computer.',
-    inputSchema: { type: 'object', properties: {} },
-    async handler() {
-      const routes = getConnectedRoutes();
-      return textResult(JSON.stringify({ routes }, null, 2));
-    },
-  },
-  {
-    name: 'artifacts_redeploy',
-    description:
-      'Redeploy an artifact: optionally update cwd/build/start/port settings, run its build command if configured, then restart the production process. DNS connection state is preserved.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        artifact_id: { type: 'string' },
-        cwd: { type: 'string' },
-        port: { type: 'number' },
-        build_command: { type: 'string' },
-        start_command: { type: 'string' },
-        autostart: { type: 'boolean' },
-        keep_alive: { type: 'boolean' },
-      },
-      required: ['artifact_id'],
-    },
-    async handler(args) {
-      try {
-        const artifact = await redeployArtifact(args.artifact_id, args || {});
-        return textResult(`Artifact redeployed.\n\n${artifactSummary(artifact)}`);
-      } catch (err) {
-        return errorResult(err.message);
-      }
-    },
-  },
-  {
-    name: 'artifacts_disconnect_dns',
-    description:
-      'Disconnect an artifact from artifact DNS without stopping the local process. The artifact remains registered locally and can be reconnected later.',
-    inputSchema: {
-      type: 'object',
-      properties: { artifact_id: { type: 'string' } },
-      required: ['artifact_id'],
-    },
-    async handler({ artifact_id }) {
-      try {
-        const artifact = await disconnectDns(artifact_id);
-        return textResult(`Artifact DNS disconnected.\n\n${artifactSummary(artifact)}`);
-      } catch (err) {
-        return errorResult(err.message);
-      }
-    },
-  },
-  {
-    name: 'artifacts_connect_dns',
-    description: 'Reconnect a registered artifact to artifact DNS.',
-    inputSchema: {
-      type: 'object',
-      properties: { artifact_id: { type: 'string' } },
-      required: ['artifact_id'],
-    },
-    async handler({ artifact_id }) {
-      try {
-        const artifact = await connectDns(artifact_id);
-        return textResult(`Artifact DNS connected.\n\n${artifactSummary(artifact)}`);
-      } catch (err) {
-        return errorResult(err.message);
-      }
-    },
-  },
-  {
-    name: 'artifacts_start',
-    description: 'Start a stopped registered artifact using its production start command.',
-    inputSchema: {
-      type: 'object',
-      properties: { artifact_id: { type: 'string' } },
-      required: ['artifact_id'],
-    },
-    async handler({ artifact_id }) {
-      try {
-        const artifact = await startArtifact(artifact_id);
-        return textResult(`Artifact started.\n\n${artifactSummary(artifact)}`);
-      } catch (err) {
-        return errorResult(err.message);
-      }
-    },
-  },
-  {
-    name: 'artifacts_stop',
-    description: 'Stop a registered artifact and mark it as intentionally stopped.',
-    inputSchema: {
-      type: 'object',
-      properties: { artifact_id: { type: 'string' } },
-      required: ['artifact_id'],
-    },
-    async handler({ artifact_id }) {
-      try {
-        const artifact = await stopArtifact(artifact_id);
-        return textResult(`Artifact stopped.\n\n${artifactSummary(artifact)}`);
-      } catch (err) {
-        return errorResult(err.message);
-      }
-    },
-  },
-];

package/runtime/scripts/amalgm-mcp/events/executor.js

@@ -1,258 +0,0 @@
-/**
- * Event-fired agent execution.
- *
- * Used for both webhook-triggered event runs and (legacy) artifact-fired
- * events. Mirrors tasks/executor.js but without persisted run logs — each
- * event run gets its own one-shot Supabase session (if configured).
- */
-
-const crypto = require('crypto');
-const os = require('os');
-
-const { AMALGM_COMPUTER_ID, AMALGM_USER_ID, DEFAULT_CWD } = require('../config');
-const { runThroughChatServer } = require('../lib/chat-runner');
-const { hasSupabase, supabaseInsert, supabasePatch } = require('../lib/supabase');
-const { recordEventRun } = require('./store');
-const {
-  chatInputToLegacyFields,
-  normalizeChatInput,
-  withChatInputText,
-} = require('../../../lib/chatInput');
-const { DEFAULT_SELECTED_MODELS, resolveModelSelection } = require('../lib/prefs');
-const credentialAdapter = require('../../credential-adapter');
-const { buildLocalMcpServerConfigs } = require('../lib/mcp-resolver');
-
-function harnessToAgent(harness) {
-  const map = { claude_code: 'claude', codex: 'codex', opencode: 'opencode', pi: 'pi', amp: 'amp', cursor: 'cursor' };
-  return map[harness] || 'claude';
-}
-
-function normalizeEffort(value) {
-  if (typeof value !== 'string') return null;
-  const normalized = value.trim().toLowerCase().replace(/_/g, '-');
-  if (normalized === 'low') return 'low';
-  if (normalized === 'medium') return 'medium';
-  if (normalized === 'high') return 'high';
-  if (normalized === 'xhigh' || normalized === 'extra-high' || normalized === 'extra high') return 'xhigh';
-  if (normalized === 'max') return 'max';
-  return null;
-}
-
-function sanitizeRunModelSettings(settings, harness) {
-  if (!settings || typeof settings !== 'object') return {};
-  const effort = normalizeEffort(settings.effort || settings.reasoningEffort || settings.reasoning);
-  const allowedEfforts =
-    harness === 'claude_code'
-      ? new Set(['low', 'medium', 'high', 'xhigh', 'max'])
-      : harness === 'codex'
-        ? new Set(['low', 'medium', 'high', 'xhigh'])
-        : new Set();
-  return {
-    ...(effort && allowedEfforts.has(effort) ? { effort } : {}),
-    ...(harness === 'claude_code' && settings.fastMode === true ? { fastMode: true } : {}),
-  };
-}
-
-function modelIdForSettings(modelId, harness, modelSettings) {
-  if (harness !== 'codex' || !modelSettings.effort || typeof modelId !== 'string') return modelId;
-  return modelId
-    .replace(/(?::thinking-|-thinking-)(low|medium|high|xhigh)$/i, '')
-    .replace(/\/(low|medium|high|xhigh)$/i, '');
-}
-
-function resolveEventRequest(eventDef, projectPath) {
-  const harness =
-    (eventDef.chatInput && eventDef.chatInput.agent && eventDef.chatInput.agent.harness)
-    || eventDef.harness
-    || 'claude_code';
-  const model =
-    (eventDef.chatInput && eventDef.chatInput.agent && eventDef.chatInput.agent.model)
-    || eventDef.model
-    || DEFAULT_SELECTED_MODELS[harness]
-    || null;
-  const authMethod =
-    (eventDef.chatInput && eventDef.chatInput.agent && eventDef.chatInput.agent.authMethod)
-    || eventDef.authMethod
-    || (credentialAdapter.VALID_HARNESS_IDS.includes(harness)
-      ? credentialAdapter.getPersistedAuthMode(harness)
-      : 'amalgm');
-  const templateChatInput = normalizeChatInput(eventDef.chatInput, {
-    prompt:
-      eventDef.agent_prompt
-      || `An event "${eventDef.name}" was triggered. Payload: {payload}`,
-    harness,
-    modelId: model,
-    authMethod,
-    cwd: projectPath,
-    projectPath,
-  });
-
-  return {
-    harness,
-    templateChatInput,
-    authMethod,
-    model,
-    modelSettings: sanitizeRunModelSettings(
-      eventDef.modelSettings || (eventDef.chatInput && eventDef.chatInput.modelSettings),
-      harness,
-    ),
-  };
-}
-
-/**
- * Execute an event-triggered agent run.
- *
- * @param {{ id: string, name: string }} artifactOrTrigger - source metadata
- * @param {{ name: string, agent_prompt: string }} eventDef - trigger/event definition
- * @param {any} payload - event payload (injected into prompt via {payload})
- * @param {{ triggerId?: string, projectPath?: string }} [opts]
- */
-async function executeArtifactEvent(artifactOrTrigger, eventDef, payload, opts = {}) {
-  const { triggerId, projectPath } = opts;
-  const codeSessionId = crypto.randomUUID();
-  const userMessageId = crypto.randomUUID();
-  const assistantMessageId = crypto.randomUUID();
-  const startedAt = new Date().toISOString();
-  const { harness, templateChatInput, authMethod, model, modelSettings } = resolveEventRequest(eventDef, projectPath);
-  const payloadText = JSON.stringify(payload);
-  const chatInput = withChatInputText(templateChatInput, (text) => text.replaceAll('{payload}', payloadText));
-  const legacy = chatInputToLegacyFields(chatInput, {
-    prompt: eventDef.agent_prompt,
-    harness,
-    modelId: model,
-    authMethod,
-    cwd: projectPath,
-    projectPath,
-  });
-  const cwd = legacy.cwd || DEFAULT_CWD;
-  const runTriggerId = triggerId || artifactOrTrigger.id;
-  const modelSelection = resolveModelSelection(
-    harness,
-    modelIdForSettings(legacy.modelId || model, harness, modelSettings),
-  );
-  const mcpServers = await buildLocalMcpServerConfigs(legacy.mcpAppIds || []);
-  const reasoningEffort = modelSettings.effort || modelSelection.reasoningEffort;
-
-  console.log(
-    `[AmalgmMCP:Event] Starting agent run for ${artifactOrTrigger.id}:${eventDef.name} (session: ${codeSessionId}, cwd: ${cwd})`,
-  );
-
-  recordEventRun(runTriggerId, {
-    runId: codeSessionId,
-    sessionId: codeSessionId,
-    triggerName: eventDef.name,
-    startedAt,
-    status: 'running',
-    harness,
-    projectPath: projectPath || null,
-    prompt: legacy.prompt,
-  }, { source: 'event_runs:start' });
-
-  if (hasSupabase()) {
-    try {
-      const metadata = {
-        artifactId: artifactOrTrigger.id,
-        artifactName: artifactOrTrigger.name,
-        event: eventDef.name,
-        automated: true,
-        originName: eventDef.name,
-      };
-      if (triggerId) metadata.triggerId = triggerId;
-      await supabaseInsert('sessions', {
-        id: codeSessionId,
-        user_id: AMALGM_USER_ID,
-        computer_id: AMALGM_COMPUTER_ID,
-        container_id: os.hostname() || 'artifact-event',
-        harness,
-        title: 'New Chat',
-        origin: 'event',
-        origin_id: triggerId || artifactOrTrigger.id,
-        project_path: projectPath || null,
-        status: 'in-progress',
-        metadata,
-      });
-    } catch (err) {
-      console.error('[AmalgmMCP:Event] DB session creation failed:', err.message);
-    }
-  }
-
-  try {
-    const { outputText } = await runThroughChatServer({
-      chatInput,
-      prompt: legacy.prompt,
-      userId: AMALGM_USER_ID,
-      computerId: AMALGM_COMPUTER_ID,
-      codeSessionId,
-      assistantMessageId,
-      userMessageId,
-      userParts: legacy.userParts,
-      agentId: harnessToAgent(harness),
-      modelId: modelSelection.modelId || legacy.modelId || null,
-      cliModel: modelSelection.cliModel || null,
-      ...(reasoningEffort ? { reasoningEffort } : {}),
-      ...(modelSettings.fastMode ? { fastMode: true } : {}),
-      cwd,
-      authMethod: legacy.authMethod || authMethod,
-      mcpServers,
-      origin: {
-        type: 'event',
-        id: triggerId || artifactOrTrigger.id,
-        name: eventDef.name,
-        projectPath: projectPath || null,
-      },
-      automated: true,
-    });
-
-    const durationMs = Date.now() - new Date(startedAt).getTime();
-    console.log(
-      `[AmalgmMCP:Event] ${artifactOrTrigger.id}:${eventDef.name} completed in ${durationMs}ms (output: ${outputText.length} chars)`,
-    );
-
-    recordEventRun(runTriggerId, {
-      runId: codeSessionId,
-      sessionId: codeSessionId,
-      triggerName: eventDef.name,
-      finishedAt: new Date().toISOString(),
-      status: 'completed',
-      durationMs,
-      outputLength: outputText.length,
-    }, { source: 'event_runs:complete' });
-
-    if (hasSupabase()) {
-      supabasePatch('sessions', 'id', codeSessionId, {
-        last_message_at: new Date().toISOString(),
-        status: 'complete',
-        new_messages: true,
-      }).catch(() => {});
-    }
-  } catch (err) {
-    console.error(
-      `[AmalgmMCP:Event] ${artifactOrTrigger.id}:${eventDef.name} failed:`,
-      err.message,
-    );
-    recordEventRun(runTriggerId, {
-      runId: codeSessionId,
-      sessionId: codeSessionId,
-      triggerName: eventDef.name,
-      finishedAt: new Date().toISOString(),
-      status: 'failed',
-      error: err.message,
-    }, { source: 'event_runs:failed' });
-    if (hasSupabase()) {
-      supabasePatch('sessions', 'id', codeSessionId, {
-        last_message_at: new Date().toISOString(),
-        status: 'error',
-        new_messages: true,
-        metadata: {
-          artifactId: artifactOrTrigger.id,
-          event: eventDef.name,
-          automated: true,
-          originName: eventDef.name,
-          error: err.message,
-        },
-      }).catch(() => {});
-    }
-  }
-}
-
-module.exports = { executeArtifactEvent };

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

@@ -1,214 +0,0 @@
-/**
- * /event-triggers/* REST routes for the Next.js API to call.
- * Not part of the MCP tool surface — used by the internal UI.
- */
-
-const crypto = require('crypto');
-const { loadEventTriggers, saveEventTriggers } = require('./store');
-const { getWebhookUrl } = require('./webhook-url');
-const {
-  chatInputToLegacyFields,
-  getChatInputText,
-  normalizeChatInput,
-} = require('../../../lib/chatInput');
-const {
-  DEFAULT_SELECTED_MODELS,
-  getSelectedModel,
-  hydrateModelPreferences,
-} = require('../lib/prefs');
-const credentialAdapter = require('../../credential-adapter');
-const activeMemory = require('../../chat-core/tooling/active-memory');
-
-function resolveEventHarness(harness, chatInput) {
-  return (
-    (chatInput && chatInput.agent && typeof chatInput.agent.harness === 'string' && chatInput.agent.harness)
-    || (typeof harness === 'string' && harness)
-    || 'claude_code'
-  );
-}
-
-function resolveEventModel(harness, model) {
-  if (typeof model === 'string' && model) return model;
-  return getSelectedModel(harness) || DEFAULT_SELECTED_MODELS[harness] || null;
-}
-
-function resolveEventAuthMethod(harness, authMethod) {
-  if (typeof authMethod === 'string' && authMethod) return authMethod;
-  if (credentialAdapter.VALID_HARNESS_IDS.includes(harness)) {
-    return credentialAdapter.getPersistedAuthMode(harness);
-  }
-  return 'amalgm';
-}
-
-function buildEventChatInput(fields, existing = null) {
-  if (fields.chatInput) return fields.chatInput;
-
-  const existingNonTextParts =
-    existing && existing.chatInput && Array.isArray(existing.chatInput.parts)
-      ? existing.chatInput.parts.filter((part) => part.type !== 'text')
-      : [];
-
-  return {
-    ...(existing && existing.chatInput ? existing.chatInput : {}),
-    parts: [
-      ...existingNonTextParts,
-      ...((typeof fields.agent_prompt === 'string' && fields.agent_prompt)
-        ? [{ type: 'text', text: fields.agent_prompt }]
-        : []),
-    ],
-    agent: {
-      ...((existing && existing.chatInput && existing.chatInput.agent) || {}),
-      ...(fields.harness ? { harness: fields.harness } : {}),
-      ...(fields.model ? { model: fields.model } : {}),
-      ...(fields.authMethod ? { authMethod: fields.authMethod } : {}),
-    },
-    tools: (existing && existing.chatInput && existing.chatInput.tools) || { mcpAppIds: [] },
-    execution: {
-      ...((existing && existing.chatInput && existing.chatInput.execution) || {}),
-      ...(fields.projectPath !== undefined ? { cwd: fields.projectPath || null } : {}),
-    },
-  };
-}
-
-function normalizeEventTriggerRecord(triggerLike, existing = null) {
-  const rawChatInput = buildEventChatInput(triggerLike, existing);
-  const harness = resolveEventHarness(triggerLike.harness, rawChatInput);
-  const model = resolveEventModel(harness, triggerLike.model);
-  const authMethod = resolveEventAuthMethod(harness, triggerLike.authMethod);
-  const chatInput = normalizeChatInput(rawChatInput, {
-    prompt: triggerLike.agent_prompt,
-    harness,
-    modelId: model,
-    authMethod,
-    cwd: triggerLike.projectPath,
-    projectPath: triggerLike.projectPath,
-  });
-  const legacy = chatInputToLegacyFields(chatInput, {
-    prompt: triggerLike.agent_prompt,
-    harness,
-    modelId: model,
-    authMethod,
-    cwd: triggerLike.projectPath,
-    projectPath: triggerLike.projectPath,
-  });
-
-  return {
-    ...triggerLike,
-    chatInput,
-    agent_prompt: getChatInputText(chatInput, triggerLike.agent_prompt) || legacy.prompt,
-    harness: legacy.harness || harness,
-    model: legacy.modelId || model,
-    authMethod: legacy.authMethod || authMethod,
-    projectPath: legacy.cwd || triggerLike.projectPath || null,
-  };
-}
-
-async function handleList(req, sendJson) {
-  const data = loadEventTriggers();
-  sendJson(200, { triggers: data.triggers });
-}
-
-async function handleCreate(body, sendJson) {
-  const { name, description, source, event, agent_prompt, projectPath, harness, model, modelSettings, authMethod, chatInput } = body;
-  if (!name || !source || !event || (!agent_prompt && !chatInput)) {
-    return sendJson(400, { error: 'name, source, event, and agent_prompt or chatInput are required' });
-  }
-  await hydrateModelPreferences();
-  const data = loadEventTriggers();
-  const trigger = normalizeEventTriggerRecord({
-    id: crypto.randomUUID(),
-    name,
-    description: description || '',
-    source,
-    event,
-    agent_prompt: agent_prompt || null,
-    enabled: true,
-    webhookUrl: getWebhookUrl(),
-    secret: crypto.randomUUID().replace(/-/g, ''),
-    projectPath: projectPath || null,
-    harness: harness || null,
-    model: model || null,
-    modelSettings: modelSettings || null,
-    authMethod: authMethod || null,
-    chatInput: chatInput || null,
-    createdAt: new Date().toISOString(),
-    lastFiredAt: null,
-  });
-  data.triggers.push(trigger);
-  saveEventTriggers(data);
-  activeMemory.ensureConstructMemory({
-    type: 'event',
-    id: trigger.id,
-    name: trigger.name,
-    projectPath: trigger.projectPath,
-  }, { source: 'event:create' });
-  console.log(`[AmalgmMCP:Events] Created event trigger: ${name} (${source}:${event})`);
-  sendJson(200, { ok: true, trigger });
-}
-
-async function handleUpdate(body, sendJson) {
-  const { trigger_id, ...updates } = body;
-  if (!trigger_id) return sendJson(400, { error: 'trigger_id is required' });
-  await hydrateModelPreferences();
-  const data = loadEventTriggers();
-  const trigger = data.triggers.find((t) => t.id === trigger_id);
-  if (!trigger) return sendJson(404, { error: 'Trigger not found' });
-  Object.assign(trigger, updates, { updatedAt: new Date().toISOString() });
-  if (
-    updates.chatInput === undefined
-    && (
-      updates.agent_prompt !== undefined
-      || updates.harness !== undefined
-      || updates.model !== undefined
-      || updates.authMethod !== undefined
-      || updates.projectPath !== undefined
-    )
-  ) {
-    const existingNonTextParts = Array.isArray(trigger.chatInput?.parts)
-      ? trigger.chatInput.parts.filter((part) => part.type !== 'text')
-      : [];
-    trigger.chatInput = {
-      ...(trigger.chatInput || {}),
-      parts: [
-        ...existingNonTextParts,
-        ...((typeof trigger.agent_prompt === 'string' && trigger.agent_prompt)
-          ? [{ type: 'text', text: trigger.agent_prompt }]
-          : []),
-      ],
-      agent: {
-        ...(trigger.chatInput?.agent || {}),
-        ...(trigger.harness ? { harness: trigger.harness } : {}),
-        ...(trigger.model ? { model: trigger.model } : {}),
-        ...(trigger.authMethod ? { authMethod: trigger.authMethod } : {}),
-      },
-      tools: trigger.chatInput?.tools || { mcpAppIds: [] },
-      execution: {
-        ...(trigger.chatInput?.execution || {}),
-        ...(updates.projectPath !== undefined ? { cwd: trigger.projectPath || null } : {}),
-      },
-    };
-  }
-  Object.assign(trigger, normalizeEventTriggerRecord(trigger, trigger));
-  saveEventTriggers(data);
-  activeMemory.ensureConstructMemory({
-    type: 'event',
-    id: trigger.id,
-    name: trigger.name,
-    projectPath: trigger.projectPath,
-  }, { source: 'event:update' });
-  console.log(`[AmalgmMCP:Events] Updated trigger: ${trigger_id}`);
-  sendJson(200, { ok: true, trigger });
-}
-
-async function handleDelete(body, sendJson) {
-  const { trigger_id } = body;
-  if (!trigger_id) return sendJson(400, { error: 'trigger_id is required' });
-  const data = loadEventTriggers();
-  const idx = data.triggers.findIndex((t) => t.id === trigger_id);
-  if (idx === -1) return sendJson(404, { error: 'Trigger not found' });
-  data.triggers.splice(idx, 1);
-  saveEventTriggers(data);
-  sendJson(200, { ok: true });
-}
-
-module.exports = { handleList, handleCreate, handleUpdate, handleDelete };