amalgm 0.0.0 → 0.0.1

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

@@ -0,0 +1,100 @@
+/**
+ * amalgm-mcp — local-first MCP server.
+ *
+ * Entry point. Spawned by electron/main.ts (or runnable standalone with
+ * `node scripts/amalgm-mcp/index.js`). Stores all state under AMALGM_DIR
+ * (default: ~/.amalgm/) — same pattern as scripts/credential-adapter.js.
+ *
+ * Ports:
+ *   8083  this server
+ *   8084  chat-server (we delegate task/event/agent runs here)
+ *
+ * Modules:
+ *   config.js                   env + paths
+ *   deps.js                     cron-parser + playwright loaders
+ *   lib/                        generic utilities (storage, chat-runner,
+ *                               supabase, prefs, email-md, tool-result)
+ *   tasks/                      scheduled tasks (8 MCP tools + poll loop)
+ *   events/                     event triggers (5 MCP tools + /events ingress)
+ *   agents/                     agents CRUD + talk_to_agent
+ *   browser/                    visible Electron browser + Playwright fallback tools
+ *   notify/                     notify_user (email via proxy)
+ *   server/                     MCP JSON-RPC dispatch + HTTP route table
+ */
+
+async function ensureProxyToken() {
+  if (process.env.AMALGM_PROXY_TOKEN) return;
+  const { DEFAULT_PROXY_BASE_URL, ensureFreshProxyToken } = require('../proxy-token-store');
+  const savedToken = await ensureFreshProxyToken({ logger: console });
+  if (savedToken) {
+    process.env.AMALGM_PROXY_TOKEN = savedToken;
+    if (!process.env.AMALGM_PROXY_URL) process.env.AMALGM_PROXY_URL = DEFAULT_PROXY_BASE_URL;
+    return;
+  }
+  if (
+    process.env.AMALGM_RUNTIME_SOURCE === 'npm'
+    || process.env.AMALGM_LOCAL_MODE === 'true'
+    || process.env.AMALGM_ALLOW_ADMIN_TOKEN_MINT !== 'true'
+  ) {
+    return;
+  }
+
+  const adminSecret = process.env.PROXY_ADMIN_SECRET || process.env.ADMIN_SECRET;
+  if (!adminSecret) return;
+
+  const proxyUrl = process.env.AMALGM_PROXY_URL || 'https://amalgm-api-proxy-v2.fly.dev';
+
+  try {
+    const res = await fetch(`${proxyUrl}/internal/token`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-admin-secret': adminSecret,
+      },
+      body: JSON.stringify({
+        userId: process.env.AMALGM_USER_ID || 'local',
+        containerId: process.env.AMALGM_CONTAINER_ID || 'standalone',
+      }),
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      console.warn(`[AmalgmMCP] Failed to mint proxy token: ${res.status} ${text.slice(0, 100)}`);
+      return;
+    }
+
+    const { token } = await res.json();
+    process.env.AMALGM_PROXY_TOKEN = token;
+    if (!process.env.AMALGM_PROXY_URL) process.env.AMALGM_PROXY_URL = proxyUrl;
+    console.log('[AmalgmMCP] Minted HMAC proxy token (standalone fallback)');
+  } catch (err) {
+    console.warn(`[AmalgmMCP] Error minting proxy token: ${err.message}`);
+  }
+}
+
+async function boot() {
+  await ensureProxyToken();
+
+  const { ensureTasksDirs } = require('./tasks/store');
+  const { ensureTriggersDirs } = require('./events/store');
+  const { ensureAgentsDirs } = require('./agents/store');
+  const { ensureArtifactsDirs } = require('./artifacts/store');
+  const { startArtifactRouteSyncLoop } = require('./artifacts/advertise');
+  const { startRegisteredArtifacts } = require('./artifacts/supervisor');
+  const { listen } = require('./server/http');
+
+  // Make sure every storage dir/file exists before we accept traffic.
+  ensureTasksDirs();
+  ensureTriggersDirs();
+  ensureAgentsDirs();
+  ensureArtifactsDirs();
+
+  await listen();
+  await startRegisteredArtifacts();
+  startArtifactRouteSyncLoop();
+}
+
+boot().catch((err) => {
+  console.error('[AmalgmMCP] Boot failed:', err);
+  process.exit(1);
+});

package/runtime/scripts/amalgm-mcp/lib/chat-runner.js

@@ -0,0 +1,167 @@
+/**
+ * Chat-server runner — generic "execute a prompt via the local chat-server".
+ *
+ * Used by:
+ *  - tasks/executor.js     (scheduled task runs)
+ *  - events/executor.js    (webhook → agent runs)
+ *  - agents/talk.js        (talk_to_agent tool)
+ *  - email/inbound.js      (email replies/new email → agent runs)
+ *
+ * POSTs to chat-server (:8084) and consumes the SSE stream, accumulating
+ * text from agent_message_chunk events and returning the final output.
+ */
+
+const { CHAT_SERVER_URL } = require('../config');
+const { runtimeAuthHeaders } = require('../../runtime-auth');
+
+/**
+ * Run a prompt through the chat-server and return the assembled output text.
+ *
+ * @param {object} payload - body sent to POST /chat (prompt, codeSessionId, agentId, cwd, ...)
+ * @param {AbortSignal} [signal]
+ * @param {{ onEvent?: (event: object, metrics: object) => void }} [options]
+ * @returns {Promise<{ outputText: string, stopReason: string | null, usage: object | null, metrics: object }>}
+ */
+async function runThroughChatServer(payload, signal, options = {}) {
+  const startedAt = Date.now();
+  const res = await fetch(`${CHAT_SERVER_URL}/chat`, {
+    method: 'POST',
+    headers: runtimeAuthHeaders({ 'Content-Type': 'application/json' }),
+    body: JSON.stringify(payload),
+    ...(signal ? { signal } : {}),
+  });
+  if (!res.ok) {
+    const errText = await res.text().catch(() => '');
+    throw new Error(`chat-server returned ${res.status}: ${errText.slice(0, 200)}`);
+  }
+
+  let outputText = '';
+  let stopReason = null;
+  let usage = null;
+  let sawComplete = false;
+  let sawError = false;
+  const toolCalls = new Map();
+  const metrics = {
+    textChunks: 0,
+    reasoningChunks: 0,
+    toolEvents: 0,
+    usageEvents: 0,
+  };
+
+  const notifyEvent = (event) => {
+    if (typeof options.onEvent !== 'function') return;
+    try {
+      options.onEvent(event, {
+        ...metrics,
+        sawComplete,
+        sawError,
+        outputText,
+        outputTextLength: outputText.length,
+        wallTimeMs: Date.now() - startedAt,
+        toolCalls: [...toolCalls.values()],
+      });
+    } catch {
+      // Observability hooks must not interrupt the agent run.
+    }
+  };
+
+  const handleEvent = (event) => {
+    if (event._type === 'update' && event.sessionUpdate === 'agent_message_chunk') {
+      if (event.content?.type === 'text' && event.content.text) {
+        outputText += event.content.text;
+        metrics.textChunks += 1;
+      }
+      notifyEvent(event);
+      return;
+    }
+    if (event._type === 'update' && event.sessionUpdate === 'agent_thought_chunk') {
+      metrics.reasoningChunks += 1;
+      notifyEvent(event);
+      return;
+    }
+    if (event._type === 'update' && (event.sessionUpdate === 'tool_call' || event.sessionUpdate === 'tool_call_update')) {
+      metrics.toolEvents += 1;
+      const id = event.toolCallId || `tool-${metrics.toolEvents}`;
+      const current = toolCalls.get(id) || { id };
+      toolCalls.set(id, {
+        ...current,
+        title: event.title || current.title,
+        kind: event.kind || current.kind,
+        status: event.status || current.status,
+      });
+      notifyEvent(event);
+      return;
+    }
+    if (event._type === 'update' && event.sessionUpdate === 'usage_update') {
+      usage = event.usage || usage;
+      metrics.usageEvents += 1;
+      notifyEvent(event);
+      return;
+    }
+    if (event._type === 'complete') {
+      stopReason = event.stopReason || null;
+      usage = event.usage || usage;
+      sawComplete = true;
+      notifyEvent(event);
+      return;
+    }
+    if (event._type === 'error') {
+      sawError = true;
+      notifyEvent(event);
+      throw new Error(event.message || 'chat-server error');
+    }
+    notifyEvent(event);
+  };
+
+  const handleLine = (line) => {
+    if (!line.startsWith('data: ')) return;
+    const data = line.slice(6).trim();
+    if (!data) return;
+    const event = JSON.parse(data);
+    handleEvent(event);
+  };
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      try {
+        handleLine(line);
+      } catch (e) {
+        // Swallow JSON parse errors on partial lines; re-throw everything else.
+        if (!(e instanceof SyntaxError)) throw e;
+      }
+    }
+  }
+
+  if (buffer.trim()) {
+    try {
+      handleLine(buffer);
+    } catch (e) {
+      if (!(e instanceof SyntaxError)) throw e;
+    }
+  }
+
+  return {
+    outputText,
+    stopReason,
+    usage,
+    metrics: {
+      ...metrics,
+      sawComplete,
+      sawError,
+      wallTimeMs: Date.now() - startedAt,
+      toolCalls: [...toolCalls.values()],
+    },
+  };
+}
+
+module.exports = { runThroughChatServer };

package/runtime/scripts/amalgm-mcp/lib/email-md.js

@@ -0,0 +1,288 @@
+/**
+ * Email markdown → inline-styled HTML.
+ *
+ * Line-based parser: processes each line sequentially, accumulates contiguous
+ * blocks of the same type (list items, table rows, paragraph text, etc.) and
+ * flushes when the type changes. Headings, tables, and lists are detected
+ * even without blank-line separators.
+ *
+ * Output is inline-styled HTML suitable for email clients that strip <style>
+ * tags. Colors match the amalgm dark theme.
+ */
+
+function escapeHtmlAttr(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function escapeHtmlText(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+// Inline citation chip for amalgm:// references (files, folders, skills, agents).
+// Non-clickable in email — local resources can't be opened from a mail client —
+// but the chip preserves visual continuity with the in-app render.
+const AMALGM_KIND_ICONS = {
+  file: '\u{1F4C4}', // 📄
+  folder: '\u{1F4C1}', // 📁
+  skill: '\u{2728}', // ✨
+  agent: '@',
+};
+
+function renderAmalgmCitation(label, kindAndPath, description) {
+  const slashIdx = kindAndPath.indexOf('/');
+  const kind = slashIdx === -1 ? kindAndPath : kindAndPath.slice(0, slashIdx);
+  const icon = AMALGM_KIND_ICONS[kind] || '\u{1F4CE}'; // 📎 fallback
+  const titleAttr = description ? ` title="${escapeHtmlAttr(description)}"` : '';
+  const safeLabel = escapeHtmlText(label);
+  return `<span style="display:inline-block;background:#0c0a09;border:1px solid #1c1917;border-radius:9999px;padding:1px 8px;font-size:12px;color:#ffffff;line-height:1.5;white-space:nowrap"${titleAttr}>${icon}&nbsp;${safeLabel}</span>`;
+}
+
+/**
+ * Inline format: bold, italic, code, links, images, amalgm:// citation chips.
+ */
+function inlineFormat(text) {
+  return (
+    text
+      // Images: ![alt](url)
+      .replace(
+        /!\[([^\]]*)\]\(([^)]+)\)/g,
+        '<img src="$2" alt="$1" style="max-width:100%;height:auto;border-radius:8px;margin:8px 0">',
+      )
+      // amalgm:// citations (run before generic link regex so the optional
+      // title attribute doesn't get swallowed into the href). Format:
+      //   [label](amalgm://kind/encoded-path)
+      //   [label](amalgm://kind/encoded-path "description")
+      .replace(
+        /\[([^\]]+)\]\(amalgm:\/\/([^\s)"]+)(?:\s+"([^"]*)")?\)/g,
+        (_, label, kindAndPath, description) =>
+          renderAmalgmCitation(label, kindAndPath, description),
+      )
+      // Links: [text](url)
+      .replace(
+        /\[([^\]]+)\]\(([^)]+)\)/g,
+        '<a href="$2" style="color:#ffffff;text-decoration:underline;text-underline-offset:2px" target="_blank">$1</a>',
+      )
+      // Bold + italic: ***text***
+      .replace(
+        /\*{3}(.+?)\*{3}/g,
+        '<strong style="color:#ffffff;font-weight:600"><em>$1</em></strong>',
+      )
+      // Bold: **text**
+      .replace(/\*{2}(.+?)\*{2}/g, '<strong style="color:#ffffff;font-weight:600">$1</strong>')
+      // Italic: *text* / _text_
+      .replace(/(?<!\w)\*(.+?)\*(?!\w)/g, '<em>$1</em>')
+      .replace(/(?<!\w)_(.+?)_(?!\w)/g, '<em>$1</em>')
+      // Inline code: `text`
+      .replace(
+        /`([^`]+)`/g,
+        '<code style="background:#1c1917;padding:2px 6px;border-radius:4px;font-size:13px;font-family:\'SF Mono\',SFMono-Regular,Menlo,Consolas,monospace;color:#a8a29e">$1</code>',
+      )
+  );
+}
+
+function markdownToEmailHtml(md) {
+  let text = md.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  // Normalize literal \n sequences (LLMs sometimes send \\n in JSON).
+  text = text.replace(/\\n/g, '\n');
+
+  // Extract fenced code blocks first so line parser doesn't touch them.
+  const codeBlocks = [];
+  text = text.replace(/```(\w*)\n([\s\S]*?)```/g, (_, _lang, code) => {
+    const escaped = code.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const placeholder = `%%CODEBLOCK_${codeBlocks.length}%%`;
+    codeBlocks.push(
+      `<pre style="background:#0a0a0a;border:1px solid #1c1917;border-radius:8px;padding:12px 16px;font-size:13px;font-family:'SF Mono',SFMono-Regular,Menlo,Consolas,monospace;color:#f5f5f4;overflow-x:auto;margin:16px 0;line-height:1.5"><code>${escaped.trimEnd()}</code></pre>`,
+    );
+    return placeholder;
+  });
+
+  const lines = text.split('\n');
+  const out = [];
+
+  let paraLines = [];
+  let listItems = [];
+  let listType = '';
+  let tableRows = [];
+  let quoteLines = [];
+
+  function flushPara() {
+    if (!paraLines.length) return;
+    const content = inlineFormat(paraLines.join('\n')).replace(/\n/g, '<br>');
+    out.push(`<p style="margin:12px 0;line-height:1.7;color:#ffffff">${content}</p>`);
+    paraLines = [];
+  }
+  function flushList() {
+    if (!listItems.length) return;
+    const tag = listType;
+    const items = listItems
+      .map((t) => `<li style="margin:4px 0;color:#ffffff">${inlineFormat(t)}</li>`)
+      .join('');
+    out.push(
+      `<${tag} style="margin:12px 0;padding-left:24px;color:#ffffff">${items}</${tag}>`,
+    );
+    listItems = [];
+    listType = '';
+  }
+  function flushTable() {
+    if (tableRows.length < 2) {
+      paraLines.push(...tableRows.map((r) => r._raw));
+      tableRows = [];
+      return;
+    }
+    const headerCells = tableRows[0].cells;
+    const bodyRows = tableRows.slice(1);
+    const hdr = headerCells
+      .map(
+        (c) =>
+          `<th style="background:#292524;padding:8px 12px;text-align:left;font-size:13px;font-weight:600;color:#ffffff;border:1px solid #44403c">${inlineFormat(c)}</th>`,
+      )
+      .join('');
+    const body = bodyRows
+      .map(
+        (r) =>
+          '<tr>' +
+          r.cells
+            .map(
+              (c) =>
+                `<td style="padding:8px 12px;font-size:13px;color:#d6d3d1;border:1px solid #44403c">${inlineFormat(c)}</td>`,
+            )
+            .join('') +
+          '</tr>',
+      )
+      .join('');
+    out.push(
+      `<table style="width:100%;border-collapse:collapse;margin:16px 0;background:#1c1917;border-radius:8px;overflow:hidden"><thead><tr>${hdr}</tr></thead><tbody>${body}</tbody></table>`,
+    );
+    tableRows = [];
+  }
+  function flushQuote() {
+    if (!quoteLines.length) return;
+    const content = inlineFormat(quoteLines.join('\n')).replace(/\n/g, '<br>');
+    out.push(
+      `<blockquote style="margin:16px 0;padding:8px 16px;border-left:3px solid #44403c;color:#d6d3d1;font-style:italic">${content}</blockquote>`,
+    );
+    quoteLines = [];
+  }
+  function flushAll() {
+    flushPara();
+    flushList();
+    flushTable();
+    flushQuote();
+  }
+
+  function parseTableRow(line) {
+    const t = line.trim();
+    if (!t.startsWith('|') || !t.endsWith('|')) return null;
+    const cells = t.slice(1, -1).split('|').map((c) => c.trim());
+    if (cells.every((c) => /^[-:]+$/.test(c))) return 'separator';
+    return cells;
+  }
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (/^%%CODEBLOCK_\d+%%$/.test(trimmed)) {
+      flushAll();
+      const idx = parseInt(trimmed.match(/\d+/)[0], 10);
+      out.push(codeBlocks[idx]);
+      continue;
+    }
+    if (!trimmed) {
+      flushAll();
+      continue;
+    }
+    if (/^(-{3,}|_{3,}|\*{3,})$/.test(trimmed)) {
+      flushAll();
+      out.push('<hr style="border:none;border-top:1px solid #292524;margin:24px 0">');
+      continue;
+    }
+    const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      flushAll();
+      const level = headingMatch[1].length;
+      const sizes = { 1: '22px', 2: '18px', 3: '16px', 4: '15px', 5: '14px', 6: '13px' };
+      out.push(
+        `<h${level} style="margin:20px 0 8px;font-size:${sizes[level]};font-weight:600;color:#ffffff;line-height:1.3">${inlineFormat(headingMatch[2])}</h${level}>`,
+      );
+      continue;
+    }
+    if (/^>\s?/.test(trimmed)) {
+      flushPara();
+      flushList();
+      flushTable();
+      quoteLines.push(trimmed.replace(/^>\s?/, ''));
+      continue;
+    } else if (quoteLines.length) {
+      flushQuote();
+    }
+
+    const tableResult = parseTableRow(trimmed);
+    if (tableResult === 'separator') continue;
+    if (tableResult) {
+      flushPara();
+      flushList();
+      flushQuote();
+      tableRows.push({ cells: tableResult, _raw: trimmed });
+      continue;
+    } else if (tableRows.length) {
+      flushTable();
+    }
+
+    const ulMatch = trimmed.match(/^\s*[-*]\s+(.*)/);
+    if (ulMatch) {
+      if (listType === 'ol') flushList();
+      flushPara();
+      flushTable();
+      flushQuote();
+      listType = 'ul';
+      listItems.push(ulMatch[1]);
+      continue;
+    }
+    const olMatch = trimmed.match(/^\s*\d+\.\s+(.*)/);
+    if (olMatch) {
+      if (listType === 'ul') flushList();
+      flushPara();
+      flushTable();
+      flushQuote();
+      listType = 'ol';
+      listItems.push(olMatch[1]);
+      continue;
+    }
+    if (listItems.length) flushList();
+
+    paraLines.push(trimmed);
+  }
+
+  flushAll();
+  return out.join('\n');
+}
+
+/**
+ * Wrap the converted markdown body in a full notification email shell.
+ */
+function formatNotificationEmail(message, link) {
+  const htmlMessage = markdownToEmailHtml(message);
+  const linkHtml = link
+    ? `<p style="margin:24px 0 0"><a href="${link}" style="color:#ffffff;text-decoration:underline;font-size:14px">View details &rarr;</a></p>`
+    : '';
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"></head>
+<body style="margin:0;padding:0;background:#000000;font-family:'SF Pro Text',-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,'Helvetica Neue',sans-serif;-webkit-font-smoothing:antialiased">
+<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background:#000000"><tr><td align="center" style="padding:0">
+  <table role="presentation" width="520" cellpadding="0" cellspacing="0" style="max-width:520px;width:100%"><tr><td style="padding:40px 28px 48px">
+    <div style="font-size:15px;color:#ffffff">${htmlMessage}</div>
+    ${linkHtml}
+    <p style="margin:48px 0 0;font-size:12px;color:#ffffff">amalgm.ai</p>
+  </td></tr></table>
+</td></tr></table>
+</body></html>`;
+}
+
+module.exports = { markdownToEmailHtml, formatNotificationEmail };

package/runtime/scripts/amalgm-mcp/lib/mcp-resolver.js

@@ -0,0 +1,63 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { buildSessionConfig, getMcpApp } = require('../../../lib/mcpApps/registry.js');
+
+const CONNECTIONS_FILE = path.join(os.homedir(), '.amalgm', 'mcp-connections.json');
+
+function readConnectionsFile() {
+  try {
+    const raw = fs.readFileSync(CONNECTIONS_FILE, 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : { connections: {} };
+  } catch {
+    return { connections: {} };
+  }
+}
+
+async function buildLocalMcpServerConfigs(appIds) {
+  if (!Array.isArray(appIds) || appIds.length === 0) return [];
+
+  const file = readConnectionsFile();
+  const configs = [];
+
+  for (const appId of [...new Set(appIds)]) {
+    const app = getMcpApp(appId);
+    if (!app) continue;
+
+    const conn = file.connections?.[appId];
+
+    if (app.authType === 'api_key') {
+      if (!conn?.apiKey) continue;
+      configs.push(
+        buildSessionConfig(
+          app,
+          { apiKey: conn.apiKey },
+          { instanceUrl: conn.instanceUrl, config: conn.config },
+        ),
+      );
+      continue;
+    }
+
+    if (app.authType === 'oauth') {
+      if (!conn?.accessToken) continue;
+      configs.push(
+        buildSessionConfig(
+          app,
+          { accessToken: conn.accessToken },
+          { instanceUrl: conn.instanceUrl, config: conn.config },
+        ),
+      );
+      continue;
+    }
+
+    configs.push(buildSessionConfig(app));
+  }
+
+  return configs;
+}
+
+module.exports = {
+  buildLocalMcpServerConfigs,
+};