amalgm 0.0.0 → 0.0.1

package/runtime/scripts/amalgm-mcp/lib/tool-result.js

@@ -0,0 +1,177 @@
+/**
+ * MCP tool result helpers.
+ */
+
+function textResult(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function errorResult(text) {
+  return { content: [{ type: 'text', text }], isError: true };
+}
+
+function clipText(value, max = 80) {
+  if (typeof value !== 'string') return '';
+  const trimmed = value.trim();
+  if (!trimmed) return '';
+  return trimmed.length > max ? `${trimmed.slice(0, max - 1)}...` : trimmed;
+}
+
+function quoteIfPresent(value, max = 60) {
+  const clipped = clipText(value, max);
+  return clipped ? ` "${clipped}"` : '';
+}
+
+function humanizeToolName(toolName) {
+  return String(toolName || '')
+    .replace(/^amalgm[_-]/i, '')
+    .replace(/^mcp[_-]/i, '')
+    .replace(/[_-]+/g, ' ')
+    .trim();
+}
+
+function buildActionDescriptor(toolName, args = {}) {
+  switch (toolName) {
+    case 'scheduled_tasks_create':
+      return `Create scheduled task${quoteIfPresent(args.name)}`;
+    case 'scheduled_tasks_list':
+      return args.enabled_only ? 'List enabled scheduled tasks' : 'List scheduled tasks';
+    case 'scheduled_tasks_get':
+      return `Get scheduled task${quoteIfPresent(args.task_id)}`;
+    case 'scheduled_tasks_update':
+      return `Update scheduled task${quoteIfPresent(args.task_id || args.name)}`;
+    case 'scheduled_tasks_delete':
+      return `Delete scheduled task${quoteIfPresent(args.task_id)}`;
+    case 'scheduled_tasks_run_now':
+      return `Run scheduled task now${quoteIfPresent(args.task_id)}`;
+    case 'scheduled_tasks_cancel':
+      return `Cancel scheduled task${quoteIfPresent(args.task_id)}`;
+    case 'scheduled_tasks_history':
+      return `Get scheduled task history${quoteIfPresent(args.task_id)}`;
+    case 'event_triggers_create':
+      return `Create event trigger${quoteIfPresent(args.name)}`;
+    case 'event_triggers_list':
+      return args.enabled_only ? 'List enabled event triggers' : 'List event triggers';
+    case 'event_triggers_get':
+      return `Get event trigger${quoteIfPresent(args.trigger_id)}`;
+    case 'event_triggers_update':
+      return `Update event trigger${quoteIfPresent(args.trigger_id || args.name)}`;
+    case 'event_triggers_delete':
+      return `Delete event trigger${quoteIfPresent(args.trigger_id)}`;
+    case 'notify_user':
+      return `Notify user${quoteIfPresent(args.subject || args.level || 'info')}`;
+    case 'agents_list':
+      return 'List agents';
+    case 'agents_get':
+      return `Get agent${quoteIfPresent(args.agent_id)}`;
+    case 'talk_to_agent':
+      if (args.response_to_caller) return 'Deliver peer response';
+      return `Talk to agent${quoteIfPresent(args.agent || args.agent_id)}`;
+    case 'browser_navigate':
+      return args.url ? `Navigate browser to ${clipText(args.url, 90)}` : 'Navigate browser';
+    case 'browser_tabs_list':
+      return 'List browser tabs';
+    case 'browser_tabs_selected':
+      return 'Get selected browser tab';
+    case 'browser_tabs_new':
+      return args.url ? `Open browser tab ${clipText(args.url, 90)}` : 'Open browser tab';
+    case 'browser_tabs_get':
+      return 'Get browser tab';
+    case 'browser_tabs_select':
+      return 'Select browser tab';
+    case 'browser_tabs_close':
+      return 'Close browser tab';
+    case 'browser_state':
+      return 'Get browser state';
+    case 'browser_back':
+      return 'Go back in browser';
+    case 'browser_forward':
+      return 'Go forward in browser';
+    case 'browser_reload':
+      return 'Reload browser';
+    case 'browser_screenshot':
+      return args.full_page ? 'Take full-page browser screenshot' : 'Take browser screenshot';
+    case 'browser_snapshot':
+      return 'Capture browser snapshot';
+    case 'browser_click':
+      if (args.text) return `Click browser text${quoteIfPresent(args.text)}`;
+      if (args.selector) return `Click browser selector${quoteIfPresent(args.selector)}`;
+      return 'Click in browser';
+    case 'browser_type':
+      if (args.selector && args.text) {
+        return `Type ${clipText(args.text, 40)} into ${clipText(args.selector, 40)}`;
+      }
+      if (args.selector) return `Type into ${clipText(args.selector, 60)}`;
+      return args.text ? `Type ${clipText(args.text, 40)} in browser` : 'Type in browser';
+    case 'browser_press':
+      return args.key ? `Press ${clipText(args.key, 30)} in browser` : 'Press key in browser';
+    case 'browser_get_text':
+      return args.selector
+        ? `Get browser text from ${clipText(args.selector, 60)}`
+        : 'Get browser page text';
+    case 'browser_locator_count':
+      return 'Count browser locator';
+    case 'browser_locator_text':
+      return 'Read browser locator text';
+    case 'browser_evaluate':
+      return 'Evaluate browser script';
+    case 'browser_wait_for_load_state':
+      return 'Wait for browser load state';
+    case 'browser_wait_for_url':
+      return args.url ? `Wait for browser URL ${clipText(args.url, 80)}` : 'Wait for browser URL';
+    case 'browser_wait_for_selector':
+      return args.selector ? `Wait for browser selector ${clipText(args.selector, 60)}` : 'Wait for browser selector';
+    case 'browser_cua_click':
+      return 'Click browser coordinates';
+    case 'browser_cua_double_click':
+      return 'Double-click browser coordinates';
+    case 'browser_cua_move':
+      return 'Move browser cursor';
+    case 'browser_cua_scroll':
+      return 'Scroll browser';
+    case 'browser_cua_type':
+      return args.text ? `Type ${clipText(args.text, 40)} in browser` : 'Type in browser';
+    case 'browser_cua_keypress':
+      return 'Press browser key';
+    case 'browser_cua_drag':
+      return 'Drag in browser';
+    case 'browser_cua_screenshot':
+      return 'Take visible browser screenshot';
+    case 'browser_clipboard_read_text':
+      return 'Read browser clipboard';
+    case 'browser_clipboard_write_text':
+      return 'Write browser clipboard';
+    case 'browser_start_video':
+      return 'Start browser video recording';
+    case 'browser_stop_video':
+      return 'Stop browser video recording';
+    case 'browser_close':
+      return 'Close browser';
+    default: {
+      const humanized = humanizeToolName(toolName);
+      return humanized ? humanized.charAt(0).toUpperCase() + humanized.slice(1) : 'Tool call';
+    }
+  }
+}
+
+function attachActionDescriptor(result, toolName, args = {}) {
+  if (!result || typeof result !== 'object') return result;
+
+  const existingDescriptor =
+    (typeof result.actionDescriptor === 'string' && result.actionDescriptor.trim())
+    || (typeof result.metadata?.actionDescriptor === 'string' && result.metadata.actionDescriptor.trim());
+
+  if (existingDescriptor) return result;
+
+  const actionDescriptor = buildActionDescriptor(toolName, args);
+  if (!actionDescriptor) return result;
+
+  const metadata =
+    result.metadata && typeof result.metadata === 'object'
+      ? { ...result.metadata, actionDescriptor: result.metadata.actionDescriptor || actionDescriptor }
+      : { actionDescriptor };
+
+  return { ...result, actionDescriptor, metadata };
+}
+
+module.exports = { textResult, errorResult, buildActionDescriptor, attachActionDescriptor };

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

@@ -0,0 +1,80 @@
+/**
+ * /local/* REST routes for the Next.js API to call.
+ * Not part of the MCP tool surface — used by the internal UI.
+ */
+
+const {
+  discoverAgents,
+  resolveAgentEnv,
+} = require('../../../lib/local/credentialResolver.js');
+const {
+  ensureAmalgmDir,
+  getHomeDir,
+  writeResource,
+} = require('../../../lib/local/amalgmStore.js');
+
+function cacheDiscovery(agents) {
+  writeResource('agents/discovery.json', {
+    version: 1,
+    lastScan: new Date().toISOString(),
+    discovered: agents,
+  });
+}
+
+async function handleInit(sendJson) {
+  try {
+    const { created, path: amalgmPath } = ensureAmalgmDir();
+    const agents = discoverAgents();
+    cacheDiscovery(agents);
+
+    sendJson(200, {
+      ok: true,
+      created,
+      amalgmPath,
+      homedir: getHomeDir(),
+      agents,
+    });
+  } catch (error) {
+    sendJson(500, {
+      error: error instanceof Error ? error.message : 'Failed to initialize computer environment',
+    });
+  }
+}
+
+async function handleCredentials(sendJson) {
+  try {
+    const agents = discoverAgents();
+    cacheDiscovery(agents);
+    sendJson(200, {
+      agents,
+      homedir: getHomeDir(),
+    });
+  } catch (error) {
+    sendJson(500, {
+      error: error instanceof Error ? error.message : 'Failed to discover credentials',
+    });
+  }
+}
+
+async function handleResolve(body, sendJson) {
+  try {
+    const { agentId, authMode, proxyToken, proxyBaseUrl } = body || {};
+
+    if (!agentId || !authMode) {
+      return sendJson(400, { error: 'agentId and authMode are required' });
+    }
+
+    const env = resolveAgentEnv(agentId, authMode, proxyToken, proxyBaseUrl);
+    sendJson(200, { env });
+  } catch (error) {
+    sendJson(500, {
+      error: error instanceof Error ? error.message : 'Failed to resolve credentials',
+    });
+  }
+}
+
+module.exports = {
+  handleCredentials,
+  handleInit,
+  handleResolve,
+};

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

@@ -0,0 +1,151 @@
+/**
+ * /mcp-connections REST routes for the Next.js API to call.
+ * Not part of the MCP tool surface — used by the internal UI.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { AMALGM_DIR } = require('../config');
+
+const CONNECTIONS_FILE = path.join(AMALGM_DIR, 'mcp-connections.json');
+const CLAUDE_FILE = path.join(os.homedir(), '.claude.json');
+
+function emptyFile() {
+  return { version: 1, connections: {} };
+}
+
+function ensureParentDir(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function readConnectionsFile() {
+  try {
+    const raw = fs.readFileSync(CONNECTIONS_FILE, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object' && parsed.connections && typeof parsed.connections === 'object') {
+      return parsed;
+    }
+    return emptyFile();
+  } catch {
+    return emptyFile();
+  }
+}
+
+function writeConnectionsFile(data) {
+  ensureParentDir(CONNECTIONS_FILE);
+  fs.writeFileSync(CONNECTIONS_FILE, JSON.stringify(data, null, 2));
+}
+
+function sanitizeConnections(connections) {
+  const sanitized = {};
+
+  for (const [appId, conn] of Object.entries(connections || {})) {
+    sanitized[appId] = {
+      enabled: !!conn.enabled,
+      authType: conn.authType,
+      instanceUrl: conn.instanceUrl,
+      config: conn.config,
+    };
+
+    if (conn.authType === 'oauth') {
+      sanitized[appId].hasToken = !!conn.accessToken;
+    } else if (conn.authType === 'api_key') {
+      sanitized[appId].keyHint = conn.apiKey ? `...${String(conn.apiKey).slice(-4)}` : undefined;
+    }
+  }
+
+  return sanitized;
+}
+
+function readNativeMcps() {
+  try {
+    const raw = fs.readFileSync(CLAUDE_FILE, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed?.claudeAiMcpEverConnected) ? parsed.claudeAiMcpEverConnected : [];
+  } catch {
+    return [];
+  }
+}
+
+async function handleList(sendJson) {
+  const file = readConnectionsFile();
+  sendJson(200, {
+    connections: sanitizeConnections(file.connections),
+    nativeMcps: readNativeMcps(),
+  });
+}
+
+async function handleUpsert(body, sendJson) {
+  const {
+    appId,
+    authType,
+    apiKey,
+    accessToken,
+    refreshToken,
+    expiresAt,
+    clientId,
+    clientSecret,
+    instanceUrl,
+    config,
+    enabled,
+  } = body || {};
+
+  if (!appId || !authType) {
+    return sendJson(400, { error: 'appId and authType are required' });
+  }
+
+  if (authType === 'api_key' && !apiKey) {
+    return sendJson(400, { error: 'apiKey is required for api_key auth' });
+  }
+
+  const file = readConnectionsFile();
+  const existing = file.connections?.[appId] || {};
+
+  file.connections[appId] = {
+    ...existing,
+    enabled: enabled ?? true,
+    authType,
+    ...(apiKey ? { apiKey: String(apiKey).trim() } : {}),
+    ...(accessToken ? { accessToken } : {}),
+    ...(refreshToken ? { refreshToken } : {}),
+    ...(expiresAt ? { expiresAt } : {}),
+    ...(clientId ? { clientId } : {}),
+    ...(clientSecret ? { clientSecret } : {}),
+    ...(instanceUrl ? { instanceUrl } : {}),
+    ...(config ? { config } : {}),
+    updatedAt: new Date().toISOString(),
+  };
+
+  writeConnectionsFile(file);
+
+  sendJson(200, {
+    ok: true,
+    keyHint: apiKey ? `...${String(apiKey).trim().slice(-4)}` : undefined,
+  });
+}
+
+async function handleDelete(body, sendJson) {
+  const { appId } = body || {};
+
+  if (!appId) {
+    return sendJson(400, { error: 'appId is required' });
+  }
+
+  const file = readConnectionsFile();
+  if (file.connections && appId in file.connections) {
+    delete file.connections[appId];
+    writeConnectionsFile(file);
+  }
+
+  sendJson(200, { ok: true });
+}
+
+module.exports = {
+  handleDelete,
+  handleList,
+  handleUpsert,
+};

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

@@ -0,0 +1,107 @@
+/**
+ * notify_user — email notification via the Fly.io proxy /notify endpoint.
+ *
+ * Proxy handles email lookup + Resend. When the tool is called from an Amalgm
+ * session, the proxy also sets a signed Reply-To address so user replies land
+ * back in the same session.
+ */
+
+const { PROXY_BASE_URL, PROXY_TOKEN } = require('../config');
+const { ensureFreshProxyToken, readProxyToken } = require('../../proxy-token-store');
+const { formatNotificationEmail } = require('../lib/email-md');
+const { textResult, errorResult } = require('../lib/tool-result');
+
+async function notifyUserViaProxy({ subject: customSubject, message, link, sessionId }) {
+  const notifyUrl = PROXY_BASE_URL
+    ? `${PROXY_BASE_URL.replace(/\/anthropic\/?$/, '')}/notify`
+    : null;
+  if (!notifyUrl) {
+    console.warn('[AmalgmMCP:Notify] No proxy configured, cannot send notification');
+    return { ok: false, error: 'Notification proxy is not configured.' };
+  }
+  const proxyToken = await ensureFreshProxyToken({ logger: console }) || readProxyToken() || PROXY_TOKEN;
+  if (!proxyToken) {
+    console.warn('[AmalgmMCP:Notify] No proxy token configured, cannot send notification');
+    return { ok: false, error: 'Notification proxy token is not configured.' };
+  }
+
+  const subject =
+    (customSubject && customSubject.trim()) || message.slice(0, 80).replace(/\n/g, ' ');
+  const html = formatNotificationEmail(message, link || null);
+
+  try {
+    const res = await fetch(notifyUrl, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${proxyToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        subject,
+        html,
+        text: message,
+        ...(sessionId ? { sessionId } : {}),
+      }),
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      const error = `Notification proxy failed: ${res.status} ${text.slice(0, 200)}`.trim();
+      console.error(
+        `[AmalgmMCP:Notify] ${error}`,
+      );
+      return { ok: false, error };
+    }
+    const data = await res.json();
+    console.log(`[AmalgmMCP:Notify] Notification sent to ${data.email}`);
+    return { ok: true, data };
+  } catch (err) {
+    console.error('[AmalgmMCP:Notify] Error:', err.message);
+    return { ok: false, error: `Notification proxy error: ${err.message}` };
+  }
+}
+
+module.exports = [
+  {
+    name: 'notify_user',
+    description:
+      'Send a notification to the user via email (from emails@amalgm.ai). Use this to keep the user informed about important results, completions, or errors — especially during scheduled tasks, event triggers, and long-running operations where the user is likely not actively watching.\n\nBest practices:\n- Always call notify_user at the end of a scheduled task or event-triggered run.\n- For errors, include enough context that the user can act without opening the session.\n- Keep it scannable: lead with what happened, then details.\n\nFormatting: The message is rendered as full markdown. You can use headings (##), **bold**, *italic*, `inline code`, ```code blocks```, [links](url), lists (- or 1.), blockquotes (>), and --- horizontal rules. Write it like a concise status update — no greeting, no sign-off, just the information.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        subject: {
+          type: 'string',
+          description:
+            'Short email subject line (max ~80 chars). If omitted, auto-generated from the message body.',
+        },
+        message: {
+          type: 'string',
+          description: 'The email body in markdown. Supports full markdown.',
+        },
+        level: {
+          type: 'string',
+          enum: ['info', 'warning', 'error', 'success'],
+          description: 'Severity level. Defaults to info.',
+        },
+        link: { type: 'string', description: 'Optional URL for details.' },
+      },
+      required: ['message'],
+    },
+    async handler({ subject, message, level, link }, context = {}) {
+      if (!message) return errorResult('message is required');
+      const finalLevel = ['info', 'warning', 'error', 'success'].includes(level) ? level : 'info';
+      const result = await notifyUserViaProxy({
+        subject: subject || null,
+        message,
+        level: finalLevel,
+        link: link || null,
+        sessionId: context.callerSessionId || null,
+      });
+      if (!result.ok) {
+        return errorResult(result.error);
+      }
+      return textResult(
+        `Notification sent to ${result.data.email}${result.data.replyTo ? ` (replies route to this session)` : ''}.\n\nMessage: ${message}\nLevel: ${finalLevel}${link ? `\nLink: ${link}` : ''}`,
+      );
+    },
+  },
+];