amalgm 0.0.0 → 0.0.32

package/runtime/scripts/amalgm-mcp/config.js

@@ -0,0 +1,140 @@
+/**
+ * Config — env vars, ports, paths.
+ *
+ * All storage is rooted at AMALGM_DIR (default: ~/.amalgm). The orchestrator
+ * (electron/main.ts) sets AMALGM_DIR; we never hardcode /workspace or /persist.
+ * Same pattern as scripts/credential-adapter.js.
+ */
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const {
+  DEFAULT_PROXY_BASE_URL,
+  proxyBaseUrl,
+  readProxyToken,
+} = require('../proxy-token-store');
+
+const PORT = parseInt(process.env.AMALGM_MCP_PORT || '8083', 10);
+const MCP_PROTOCOL_VERSION = '2024-11-05';
+
+const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
+
+// Storage file/dir layout under AMALGM_DIR.
+const STORAGE_DIR = AMALGM_DIR; // tasks.json etc. live directly under ~/.amalgm
+const LOCAL_DB_FILE = path.join(STORAGE_DIR, 'amalgm.db');
+const TASKS_FILE = path.join(STORAGE_DIR, 'tasks.json');
+const AGENTS_FILE = path.join(STORAGE_DIR, 'agents.json');
+const ARTIFACTS_DIR = path.join(STORAGE_DIR, 'artifacts');
+const ARTIFACTS_FILE = path.join(STORAGE_DIR, 'artifacts.json');
+const COMPUTER_RECORD_FILE = path.join(STORAGE_DIR, 'computer.json');
+const COMPUTER_AUTH_FILE = path.join(STORAGE_DIR, 'auth.json');
+const TASK_RUNS_DIR = path.join(STORAGE_DIR, 'task-runs');
+const EVENT_TRIGGERS_FILE = path.join(STORAGE_DIR, 'event-triggers.json');
+const AGENT_CONVOS_DIR = path.join(STORAGE_DIR, 'agent-convos');
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+
+// Chat server (local Next.js/Electron) — same process tree; no cloud hop.
+const CHAT_SERVER_URL = `http://localhost:${process.env.CHAT_SERVER_PORT || 8084}`;
+
+const SCHEDULER_INTERVAL_MS = 30_000;
+
+// Default working directory for automated runs (was /workspace in the container).
+const DEFAULT_CWD = process.env.AMALGM_DEFAULT_CWD || os.homedir();
+
+// ── Supabase / proxy ────────────────────────────────────────────────────────
+// Sensitive provider keys live on the Fly.io api-proxy. When running locally
+// without signing in, none of this is configured and hasSupabase() returns false.
+
+const savedComputerRecord = readJson(COMPUTER_RECORD_FILE) || {};
+const savedComputerAuth = readJson(COMPUTER_AUTH_FILE) || {};
+const AMALGM_USER_ID = cleanString(process.env.AMALGM_USER_ID)
+  || cleanString(savedComputerRecord.user_id)
+  || cleanString(savedComputerAuth.user_id);
+const AMALGM_COMPUTER_ID = cleanString(process.env.AMALGM_COMPUTER_ID)
+  || cleanString(savedComputerRecord.computer_id)
+  || cleanString(savedComputerAuth.computer_id)
+  || cleanString(process.env.AMALGM_CONTAINER_ID);
+
+const PROXY_TOKEN = readProxyToken()
+  || (process.env.AMALGM_RUNTIME_SOURCE === 'npm' ? '' : process.env.ANTHROPIC_API_KEY || '');
+const PROXY_BASE_URL = proxyBaseUrl() || (PROXY_TOKEN ? DEFAULT_PROXY_BASE_URL : '');
+const SUPABASE_PROXY_URL = PROXY_BASE_URL ? `${PROXY_BASE_URL}/supabase` : '';
+
+const SUPABASE_URL_DIRECT =
+  process.env.SUPABASE_URL || process.env.NEXT_PUBLIC_SUPABASE_URL || '';
+const SUPABASE_KEY_DIRECT = process.env.SUPABASE_SERVICE_ROLE_KEY || '';
+
+const SUPABASE_URL = SUPABASE_PROXY_URL || SUPABASE_URL_DIRECT;
+const SUPABASE_AUTH_HEADERS = SUPABASE_PROXY_URL
+  ? { Authorization: `Bearer ${PROXY_TOKEN}` }
+  : { apikey: SUPABASE_KEY_DIRECT, Authorization: `Bearer ${SUPABASE_KEY_DIRECT}` };
+
+// ── Webhook public URL ──────────────────────────────────────────────────────
+// In local mode we don't have a public ingress yet. If the orchestrator plumbs
+// one in (e.g. via a tunnel to amalgm-events-proxy), it sets this env var.
+// Otherwise event-trigger records get a localhost URL as a placeholder.
+const EVENTS_PUBLIC_URL =
+  process.env.AMALGM_EVENTS_PUBLIC_URL || `http://localhost:${PORT}/events`;
+
+const ARTIFACTS_DOMAIN = process.env.AMALGM_ARTIFACTS_DOMAIN || 'artifacts.amalgm.ai';
+const ARTIFACT_PORT_MIN = parseInt(process.env.AMALGM_ARTIFACT_PORT_MIN || '9100', 10);
+const ARTIFACT_PORT_MAX = parseInt(process.env.AMALGM_ARTIFACT_PORT_MAX || '9199', 10);
+const GATEWAY_BASE_URL = (
+  process.env.AMALGM_GATEWAY_INTERNAL_URL
+  || process.env.AMALGM_GATEWAY_URL
+  || 'https://wire.events.amalgm.ai'
+).replace(/\/$/, '');
+const GATEWAY_INTERNAL_SECRET =
+  process.env.AMALGM_GATEWAY_INTERNAL_SECRET
+  || process.env.PROXY_ADMIN_SECRET
+  || process.env.ADMIN_SECRET
+  || '';
+const ARTIFACT_ROUTE_SYNC_INTERVAL_MS = parseInt(
+  process.env.AMALGM_ARTIFACT_ROUTE_SYNC_INTERVAL_MS || '30000',
+  10,
+);
+
+module.exports = {
+  PORT,
+  MCP_PROTOCOL_VERSION,
+  AMALGM_DIR,
+  STORAGE_DIR,
+  LOCAL_DB_FILE,
+  TASKS_FILE,
+  AGENTS_FILE,
+  ARTIFACTS_DIR,
+  ARTIFACTS_FILE,
+  COMPUTER_RECORD_FILE,
+  COMPUTER_AUTH_FILE,
+  TASK_RUNS_DIR,
+  EVENT_TRIGGERS_FILE,
+  AGENT_CONVOS_DIR,
+  CHAT_SERVER_URL,
+  SCHEDULER_INTERVAL_MS,
+  DEFAULT_CWD,
+  AMALGM_USER_ID,
+  AMALGM_COMPUTER_ID,
+  PROXY_TOKEN,
+  PROXY_BASE_URL,
+  SUPABASE_URL,
+  SUPABASE_AUTH_HEADERS,
+  EVENTS_PUBLIC_URL,
+  ARTIFACTS_DOMAIN,
+  ARTIFACT_PORT_MIN,
+  ARTIFACT_PORT_MAX,
+  GATEWAY_BASE_URL,
+  GATEWAY_INTERNAL_SECRET,
+  ARTIFACT_ROUTE_SYNC_INTERVAL_MS,
+};

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

@@ -0,0 +1,45 @@
+'use strict';
+
+const { AMALGM_DIR } = require('../config');
+const {
+  deleteCredential,
+  listCredentials,
+  upsertCredential,
+} = require('../../chat-core/credentials/store');
+
+async function handleList(sendJson) {
+  try {
+    sendJson(200, { credentials: listCredentials(AMALGM_DIR) });
+  } catch (error) {
+    sendJson(500, { error: error instanceof Error ? error.message : 'Failed to list credentials' });
+  }
+}
+
+async function handleSave(body, sendJson) {
+  try {
+    const saved = upsertCredential(AMALGM_DIR, {
+      id: body?.id,
+      name: body?.name,
+      key: body?.key,
+    });
+    sendJson(200, { credential: saved });
+  } catch (error) {
+    sendJson(400, { error: error instanceof Error ? error.message : 'Failed to save credential' });
+  }
+}
+
+async function handleDelete(body, sendJson) {
+  try {
+    const id = String(body?.id || '').trim();
+    if (!id) return sendJson(400, { error: 'id is required' });
+    sendJson(200, deleteCredential(AMALGM_DIR, id));
+  } catch (error) {
+    sendJson(500, { error: error instanceof Error ? error.message : 'Failed to delete credential' });
+  }
+}
+
+module.exports = {
+  handleDelete,
+  handleList,
+  handleSave,
+};

package/runtime/scripts/amalgm-mcp/deps.js

@@ -0,0 +1,40 @@
+/**
+ * Deps — resolves optional native deps (cron-parser, playwright).
+ *
+ * The container-era code looked in /opt/amalgm-mcp-dep/ first and then the
+ * global require path. Locally we only need the global require path — these
+ * are npm deps of the main repo.
+ *
+ * Playwright is lazy: we don't require() it until a browser_* tool is called.
+ * This keeps boot fast and lets the MCP server run on machines that haven't
+ * run `npx playwright install chromium` yet.
+ */
+
+function loadCronParser() {
+  try {
+    return require('cron-parser');
+  } catch (err) {
+    console.error('[AmalgmMCP] cron-parser not installed. Run: npm install cron-parser');
+    throw err;
+  }
+}
+
+let _playwrightMod = null;
+
+function loadPlaywright() {
+  if (_playwrightMod) return _playwrightMod;
+  for (const mod of ['playwright', 'playwright-core']) {
+    try {
+      _playwrightMod = require(mod);
+      console.log(`[AmalgmMCP] Loaded Playwright from: ${mod}`);
+      return _playwrightMod;
+    } catch {
+      // Try next candidate.
+    }
+  }
+  throw new Error(
+    'Playwright is not installed. Run: npm install playwright && npx playwright install chromium',
+  );
+}
+
+module.exports = { loadCronParser, loadPlaywright };

package/runtime/scripts/amalgm-mcp/email/inbound.js

@@ -0,0 +1,215 @@
+/**
+ * Email inbound handoff.
+ *
+ * The api-proxy verifies the provider ingress, resolves/creates the Supabase
+ * session, then forwards the clean inbound email payload to this local route.
+ * From here email follows the same local chat-server execution path as user
+ * input, tasks, events, and agent-to-agent conversations. The proxy is only
+ * used again to send the email reply.
+ */
+
+const crypto = require('crypto');
+
+const {
+  AMALGM_USER_ID,
+  DEFAULT_CWD,
+  PROXY_BASE_URL,
+  PROXY_TOKEN,
+} = require('../config');
+const { runThroughChatServer } = require('../lib/chat-runner');
+const { formatNotificationEmail } = require('../lib/email-md');
+const { ensureFreshProxyToken, readProxyToken } = require('../../proxy-token-store');
+const {
+  hydrateModelPreferences,
+  getSelectedModel,
+  resolveModelSelection,
+  DEFAULT_SELECTED_MODELS,
+} = require('../lib/prefs');
+const { buildLocalMcpServerConfigs } = require('../lib/mcp-resolver');
+const {
+  chatInputToLegacyFields,
+  normalizeChatInput,
+} = require('../../../lib/chatInput');
+const credentialAdapter = require('../../credential-adapter');
+
+function harnessToAgent(harness) {
+  const map = { claude_code: 'claude', codex: 'codex', opencode: 'opencode', pi: 'pi', amp: 'amp', cursor: 'cursor' };
+  return map[harness] || 'claude';
+}
+
+function asString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function normalizeSubject(subject) {
+  const trimmed = asString(subject) || 'Amalgm reply';
+  return /^re:/i.test(trimmed) ? trimmed : `Re: ${trimmed}`;
+}
+
+function isDefaultSessionTitle(title) {
+  return ['', 'New Chat', 'New session', 'New code session'].includes(String(title || '').trim());
+}
+
+function resolveBaseHarness(session) {
+  const metadata = session?.metadata || {};
+  return (
+    asString(metadata.baseHarnessId) ||
+    asString(metadata.harness) ||
+    asString(session?.harness) ||
+    'claude_code'
+  );
+}
+
+function resolveDefaultAuthMethod(baseHarnessId) {
+  if (credentialAdapter.VALID_HARNESS_IDS.includes(baseHarnessId)) {
+    return credentialAdapter.getPersistedAuthMode(baseHarnessId);
+  }
+  return 'amalgm';
+}
+
+async function sendEmailReply({ sessionId, to, subject, message, inbound }) {
+  const notifyUrl = PROXY_BASE_URL
+    ? `${PROXY_BASE_URL.replace(/\/anthropic\/?$/, '')}/email/reply`
+    : null;
+  const proxyToken = await ensureFreshProxyToken({ logger: console }) || readProxyToken() || PROXY_TOKEN;
+  if (!notifyUrl || !proxyToken) {
+    throw new Error('Email reply proxy is not configured.');
+  }
+
+  const html = formatNotificationEmail(message, null);
+  const res = await fetch(notifyUrl, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${proxyToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      sessionId,
+      to,
+      subject: normalizeSubject(subject),
+      html,
+      text: message,
+      inReplyTo: inbound.externalMessageId || inbound.inReplyTo || null,
+      references: Array.isArray(inbound.references) ? inbound.references : [],
+    }),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Email reply proxy failed: ${res.status} ${text.slice(0, 200)}`);
+  }
+  return await res.json().catch(() => ({}));
+}
+
+async function handleEmailInbound(body, sendJson) {
+  const session = body?.session;
+  const inbound = body?.inbound || {};
+  const sessionId = asString(session?.id);
+  const prompt = asString(inbound.text);
+  const from = asString(inbound.from);
+
+  if (!sessionId) return sendJson(400, { error: 'session.id is required' });
+  if (!prompt) return sendJson(400, { error: 'inbound.text is required' });
+  if (!from) return sendJson(400, { error: 'inbound.from is required' });
+
+  await hydrateModelPreferences();
+
+  const metadata = session.metadata || {};
+  const baseHarnessId = resolveBaseHarness(session);
+  const fallbackModelId =
+    asString(metadata.baseModelId) ||
+    getSelectedModel(baseHarnessId) ||
+    DEFAULT_SELECTED_MODELS[baseHarnessId] ||
+    null;
+  const defaultAuthMethod = asString(metadata.authMethod) || resolveDefaultAuthMethod(baseHarnessId);
+  const cwd = asString(metadata.cwd) || DEFAULT_CWD;
+  const computerId = asString(metadata.computerId);
+
+  const normalizedChatInput = normalizeChatInput({
+    parts: [{ type: 'text', text: prompt }],
+    agent: {
+      harness: baseHarnessId,
+      model: fallbackModelId,
+      authMethod: defaultAuthMethod,
+      customAgentId: asString(metadata.agentId) || null,
+      systemPrompt: asString(metadata.systemPrompt),
+    },
+    tools: {
+      mcpAppIds: Array.isArray(metadata.mcpAppIds) ? metadata.mcpAppIds : [],
+    },
+    execution: {
+      cwd,
+      computerId,
+    },
+  }, {
+    prompt,
+    harness: baseHarnessId,
+    modelId: fallbackModelId,
+    authMethod: defaultAuthMethod,
+    cwd,
+    computerId,
+    systemPrompt: asString(metadata.systemPrompt),
+    mcpAppIds: Array.isArray(metadata.mcpAppIds) ? metadata.mcpAppIds : [],
+  });
+
+  const legacyChatFields = chatInputToLegacyFields(normalizedChatInput, {
+    prompt,
+    harness: baseHarnessId,
+    modelId: fallbackModelId,
+    authMethod: defaultAuthMethod,
+    cwd,
+    computerId,
+    systemPrompt: asString(metadata.systemPrompt),
+  });
+  const { modelId: uiModelId, cliModel, reasoningEffort } = resolveModelSelection(
+    baseHarnessId,
+    legacyChatFields.modelId || fallbackModelId,
+  );
+  const mcpServers = await buildLocalMcpServerConfigs(legacyChatFields.mcpAppIds || []);
+  const userMessageId = crypto.randomUUID();
+  const assistantMessageId = crypto.randomUUID();
+
+  const emailContext = [
+    `Inbound email from ${from}.`,
+    inbound.subject ? `Subject: ${inbound.subject}` : '',
+    'Reply in a concise email-friendly style unless the user asks for detail.',
+  ].filter(Boolean).join('\n');
+
+  const { outputText } = await runThroughChatServer({
+    chatInput: normalizedChatInput,
+    prompt: legacyChatFields.prompt,
+    userId: AMALGM_USER_ID || session.user_id,
+    codeSessionId: sessionId,
+    assistantMessageId,
+    userMessageId,
+    userParts: legacyChatFields.userParts,
+    agentId: harnessToAgent(baseHarnessId),
+    modelId: uiModelId,
+    cliModel,
+    ...(reasoningEffort ? { reasoningEffort } : {}),
+    cwd: legacyChatFields.cwd || DEFAULT_CWD,
+    authMethod: legacyChatFields.authMethod || defaultAuthMethod,
+    mcpServers,
+    ...(legacyChatFields.systemPrompt ? { systemPrompt: legacyChatFields.systemPrompt } : {}),
+    ...(!isDefaultSessionTitle(session.title) ? { resumeSessionId: sessionId } : {}),
+    origin: 'email',
+    originId: inbound.providerMessageId || inbound.externalMessageId || inbound.providerEventId || null,
+    originName: 'Email',
+    originHarnessId: session.harness || baseHarnessId,
+    originBaseHarnessId: baseHarnessId,
+    emailContext,
+  });
+
+  const responseText = outputText.trim() || 'Done.';
+  await sendEmailReply({
+    sessionId,
+    to: from,
+    subject: inbound.subject || session.title || 'Amalgm reply',
+    message: responseText,
+    inbound,
+  });
+
+  return sendJson(200, { ok: true, sessionId, responseLength: responseText.length });
+}
+
+module.exports = { handleEmailInbound };

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

@@ -0,0 +1,179 @@
+/**
+ * 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 {
+  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 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,
+  };
+}
+
+/**
+ * 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 } = 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 modelSelection = resolveModelSelection(harness, legacy.modelId || model);
+  const mcpServers = await buildLocalMcpServerConfigs(legacy.mcpAppIds || []);
+
+  console.log(
+    `[AmalgmMCP:Event] Starting agent run for ${artifactOrTrigger.id}:${eventDef.name} (session: ${codeSessionId}, cwd: ${cwd})`,
+  );
+
+  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,
+      ...(modelSelection.reasoningEffort ? { reasoningEffort: modelSelection.reasoningEffort } : {}),
+      cwd,
+      authMethod: legacy.authMethod || authMethod,
+      mcpServers,
+      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)`,
+    );
+
+    if (hasSupabase()) {
+      supabasePatch('sessions', 'id', codeSessionId, {
+        last_message_at: new Date().toISOString(),
+        status: 'completed',
+        new_messages: true,
+      }).catch(() => {});
+    }
+  } catch (err) {
+    console.error(
+      `[AmalgmMCP:Event] ${artifactOrTrigger.id}:${eventDef.name} failed:`,
+      err.message,
+    );
+    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 };