amalgm 0.0.0 → 0.0.1

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

@@ -0,0 +1,306 @@
+/**
+ * Event-triggers MCP tools.
+ *
+ * 5 tools: create, list, get, update, delete. Create returns the webhook URL
+ * and secret that the user needs to configure in the external service.
+ */
+
+const crypto = require('crypto');
+const { textResult, errorResult } = require('../lib/tool-result');
+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');
+
+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,
+  };
+}
+
+module.exports = [
+  {
+    name: 'event_triggers_create',
+    description:
+      'Create a new event trigger that fires an agent run when a signed event is received (e.g. GitHub push, a first-party artifact event). Returns a webhook URL and secret to configure in the sender.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Human-readable trigger name (e.g. "PR merged", "Payment received")',
+        },
+        description: { type: 'string', description: 'Optional markdown description shown in the UI.' },
+        source: {
+          type: 'string',
+          description: 'Source label (e.g. "github", "stripe", "*" for any).',
+        },
+        event: { type: 'string', description: 'Event label (e.g. "push", "*" for any).' },
+        agent_prompt: {
+          type: 'string',
+          description: 'Prompt template for the agent run. Use {payload} to inject the body.',
+        },
+        projectPath: { type: 'string', description: 'Working directory path for the agent run.' },
+        harness: { type: 'string', description: 'Agent harness for the event run.' },
+        model: { type: 'string', description: 'Model ID for the event run.' },
+        authMethod: { type: 'string', description: 'Auth method for the event run.' },
+        chatInput: { type: 'object', description: 'Shared chat input shape for the event run.' },
+      },
+      required: ['name', 'source', 'event'],
+    },
+    async handler({ name, description, source, event, agent_prompt, projectPath, harness, model, authMethod, chatInput }) {
+      if (!name || (!agent_prompt && !chatInput)) return errorResult('name and agent_prompt or chatInput are required');
+      await hydrateModelPreferences();
+      const data = loadEventTriggers();
+      const trigger = normalizeEventTriggerRecord({
+        id: crypto.randomUUID(),
+        name,
+        description: description || '',
+        source: source || '*',
+        event: event || '*',
+        agent_prompt: agent_prompt || null,
+        enabled: true,
+        webhookUrl: getWebhookUrl(),
+        secret: crypto.randomUUID().replace(/-/g, ''),
+        projectPath: projectPath || null,
+        harness: harness || null,
+        model: model || null,
+        authMethod: authMethod || null,
+        chatInput: chatInput || null,
+        createdAt: new Date().toISOString(),
+        lastFiredAt: null,
+      });
+      data.triggers.push(trigger);
+      saveEventTriggers(data);
+      console.log(`[AmalgmMCP:Events] Created trigger via MCP: ${name} (${source}:${event})`);
+      return textResult(
+        `Event trigger created.\n\nWebhook URL: ${trigger.webhookUrl}\nSecret: ${trigger.secret}\n\nConfigure the sender to either sign each request with this secret or send it directly in a secret header, then POST JSON to the webhook URL.\n\n${JSON.stringify(trigger, null, 2)}`,
+      );
+    },
+  },
+  {
+    name: 'event_triggers_list',
+    description: 'List all event triggers with their webhook URLs, secrets, and status',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enabled_only: { type: 'boolean', description: 'If true, only return enabled triggers' },
+      },
+    },
+    async handler({ enabled_only }) {
+      const data = loadEventTriggers();
+      let triggers = data.triggers.map((trigger) => normalizeEventTriggerRecord(trigger));
+      if (enabled_only) triggers = triggers.filter((t) => t.enabled);
+      if (triggers.length === 0) return textResult('No event triggers found.');
+      const summary = triggers
+        .map(
+          (t) =>
+            `- ${t.name} (${t.id})\n  ${t.enabled ? 'enabled' : 'disabled'} | source: ${t.source || '*'} | event: ${t.event || '*'}\n  URL: ${t.webhookUrl}\n  project: ${t.projectPath || '(default)'}\n  last fired: ${t.lastFiredAt || 'never'}`,
+        )
+        .join('\n\n');
+      return textResult(`Event triggers:\n\n${summary}`);
+    },
+  },
+  {
+    name: 'event_triggers_get',
+    description: 'Get detailed information about a specific event trigger',
+    inputSchema: {
+      type: 'object',
+      properties: { trigger_id: { type: 'string' } },
+      required: ['trigger_id'],
+    },
+    async handler({ trigger_id }) {
+      const data = loadEventTriggers();
+      const trigger = data.triggers.find((t) => t.id === trigger_id);
+      if (!trigger) return errorResult(`Trigger not found: ${trigger_id}`);
+      return textResult(JSON.stringify(normalizeEventTriggerRecord(trigger), null, 2));
+    },
+  },
+  {
+    name: 'event_triggers_update',
+    description: 'Update properties of an existing event trigger',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        trigger_id: { type: 'string' },
+        name: { type: 'string' },
+        description: { type: 'string' },
+        source: { type: 'string' },
+        event: { type: 'string' },
+        agent_prompt: { type: 'string' },
+        enabled: { type: 'boolean' },
+        projectPath: { type: 'string' },
+        harness: { type: 'string' },
+        model: { type: 'string' },
+        authMethod: { type: 'string' },
+        chatInput: { type: 'object' },
+      },
+      required: ['trigger_id'],
+    },
+    async handler({ trigger_id, name, description, source, event, agent_prompt, enabled, projectPath, harness, model, authMethod, chatInput }) {
+      const data = loadEventTriggers();
+      const trigger = data.triggers.find((t) => t.id === trigger_id);
+      if (!trigger) return errorResult(`Trigger not found: ${trigger_id}`);
+
+      await hydrateModelPreferences();
+
+      if (name !== undefined) trigger.name = name;
+      if (description !== undefined) trigger.description = description || '';
+      if (source !== undefined) trigger.source = source;
+      if (event !== undefined) trigger.event = event;
+      if (agent_prompt !== undefined) trigger.agent_prompt = agent_prompt;
+      if (enabled !== undefined) trigger.enabled = enabled;
+      if (projectPath !== undefined) trigger.projectPath = projectPath || null;
+      if (harness !== undefined) trigger.harness = harness || null;
+      if (model !== undefined) trigger.model = model || null;
+      if (authMethod !== undefined) trigger.authMethod = authMethod || null;
+      if (chatInput !== undefined) trigger.chatInput = chatInput || null;
+      trigger.updatedAt = new Date().toISOString();
+      if (
+        chatInput === undefined
+        && (
+          agent_prompt !== undefined
+          || harness !== undefined
+          || model !== undefined
+          || authMethod !== undefined
+          || 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 || {}),
+            ...(projectPath !== undefined ? { cwd: trigger.projectPath || null } : {}),
+          },
+        };
+      }
+
+      Object.assign(trigger, normalizeEventTriggerRecord(trigger, trigger));
+
+      saveEventTriggers(data);
+      console.log(`[AmalgmMCP:Events] Updated trigger via MCP: ${trigger_id}`);
+      return textResult(`Trigger updated.\n\n${JSON.stringify(trigger, null, 2)}`);
+    },
+  },
+  {
+    name: 'event_triggers_delete',
+    description: 'Delete an event trigger permanently. The webhook URL will stop working.',
+    inputSchema: {
+      type: 'object',
+      properties: { trigger_id: { type: 'string' } },
+      required: ['trigger_id'],
+    },
+    async handler({ trigger_id }) {
+      const data = loadEventTriggers();
+      const idx = data.triggers.findIndex((t) => t.id === trigger_id);
+      if (idx === -1) return errorResult(`Trigger not found: ${trigger_id}`);
+      const deleted = data.triggers.splice(idx, 1)[0];
+      saveEventTriggers(data);
+      console.log(`[AmalgmMCP:Events] Deleted trigger via MCP: ${trigger_id} (${deleted.name})`);
+      return textResult(`Trigger "${deleted.name}" deleted.`);
+    },
+  },
+];

package/runtime/scripts/amalgm-mcp/events/webhook-url.js

@@ -0,0 +1,28 @@
+/**
+ * Webhook URL resolver — local-first.
+ *
+ * In the container era, this fetched a stable `event_ref` from Supabase and
+ * generated `https://{ref}.events.amalgm.ai/events`.
+ *
+ * Locally, we don't have a public ingress yet. The orchestrator can provide
+ * one via AMALGM_EVENTS_PUBLIC_URL (e.g. a tunnel registered with the
+ * amalgm-events-proxy); otherwise we return a localhost URL as a placeholder
+ * so the trigger record is still well-formed.
+ *
+ * The public URL is resolved at trigger-create time — existing triggers keep
+ * whatever URL they were created with until updated/recreated.
+ */
+
+const { EVENTS_PUBLIC_URL } = require('../config');
+
+/**
+ * Return the canonical webhook URL for this machine.
+ *
+ * TODO(events-url): discuss with user — cloudflared tunnel? events-proxy
+ * WebSocket tunnel? user-managed port-forward? For now, env var wins.
+ */
+function getWebhookUrl() {
+  return EVENTS_PUBLIC_URL;
+}
+
+module.exports = { getWebhookUrl };

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

@@ -0,0 +1,293 @@
+/**
+ * /fs/* REST routes for the Next.js API to call.
+ * Not part of the MCP tool surface; this is the Amalgm computer filesystem API.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TEXT_EXTENSIONS = new Set([
+  'txt', 'md', 'json', 'js', 'ts', 'tsx', 'jsx', 'py', 'html', 'css',
+  'xml', 'yaml', 'yml', 'sh', 'bash', 'env', 'gitignore', 'dockerfile',
+  'svg', 'csv', 'sql', 'toml', 'rs', 'go', 'rb', 'java', 'kt', 'swift',
+  'c', 'cpp', 'cs', 'php', 'scss', 'log', 'ini', 'cfg', 'conf',
+]);
+
+const IS_LOCAL_MACHINE = process.env.AMALGM_LOCAL_MODE === 'true';
+const CONTAINER_ROOT = process.env.AMALGM_WORKSPACE_ROOT || '/workspace';
+const MAX_READ_BYTES = Number.parseInt(process.env.AMALGM_FS_MAX_READ_BYTES || '', 10) || 25 * 1024 * 1024;
+
+function expandHome(targetPath) {
+  if (targetPath === '~') return os.homedir();
+  if (typeof targetPath === 'string' && targetPath.startsWith('~/')) {
+    return path.join(os.homedir(), targetPath.slice(2));
+  }
+  return targetPath;
+}
+
+function splitConfiguredRoots(value) {
+  if (!value) return [];
+  return value
+    .split(path.delimiter)
+    .flatMap((part) => part.split(','))
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+function configuredRootPaths() {
+  const roots = splitConfiguredRoots(process.env.AMALGM_FS_ROOTS);
+
+  if (IS_LOCAL_MACHINE) {
+    roots.push(os.homedir());
+  } else {
+    roots.push(CONTAINER_ROOT);
+  }
+
+  return Array.from(new Set(
+    roots.map((root) => path.resolve(expandHome(root))),
+  ));
+}
+
+async function existingAllowedRoots() {
+  const roots = [];
+  for (const root of configuredRootPaths()) {
+    try {
+      const real = await fs.promises.realpath(root);
+      roots.push(real);
+    } catch {
+      // Ignore configured roots that are not mounted on this computer.
+    }
+  }
+  return Array.from(new Set(roots));
+}
+
+function isWithin(root, target) {
+  const relative = path.relative(root, target);
+  return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function requestPathOrDefault(targetPath) {
+  if (typeof targetPath === 'string' && targetPath.trim()) return targetPath;
+  return IS_LOCAL_MACHINE ? os.homedir() : CONTAINER_ROOT;
+}
+
+async function nearestExistingParent(targetPath) {
+  let current = targetPath;
+  while (current && current !== path.dirname(current)) {
+    try {
+      const stats = await fs.promises.lstat(current);
+      return stats.isDirectory() || stats.isSymbolicLink() ? current : path.dirname(current);
+    } catch {
+      current = path.dirname(current);
+    }
+  }
+  return current || path.parse(targetPath).root;
+}
+
+async function assertContained(realPath) {
+  const roots = await existingAllowedRoots();
+  if (roots.length === 0) {
+    const rootHint = IS_LOCAL_MACHINE ? os.homedir() : CONTAINER_ROOT;
+    throw Object.assign(new Error(`No accessible filesystem roots configured; expected ${rootHint}`), {
+      statusCode: 500,
+    });
+  }
+
+  if (!roots.some((root) => isWithin(root, realPath))) {
+    throw Object.assign(new Error('Filesystem path is outside the approved Amalgm computer roots'), {
+      statusCode: 403,
+    });
+  }
+}
+
+async function resolveSafePath(targetPath, options = {}) {
+  const { forCreate = false } = options;
+  const requested = requestPathOrDefault(targetPath);
+
+  if (typeof requested !== 'string' || requested.length === 0) {
+    throw Object.assign(new Error('path is required'), { statusCode: 400 });
+  }
+
+  const expanded = expandHome(requested);
+  if (!path.isAbsolute(expanded)) {
+    throw Object.assign(new Error('Path must be absolute or use ~'), { statusCode: 400 });
+  }
+
+  const normalized = path.resolve(expanded);
+
+  if (!forCreate) {
+    try {
+      const real = await fs.promises.realpath(normalized);
+      await assertContained(real);
+      return normalized;
+    } catch (error) {
+      if (error && error.code === 'ENOENT') {
+        throw Object.assign(new Error('Filesystem path not found'), { statusCode: 404 });
+      }
+      throw error;
+    }
+  }
+
+  try {
+    const real = await fs.promises.realpath(normalized);
+    await assertContained(real);
+    return normalized;
+  } catch (error) {
+    if (!error || error.code !== 'ENOENT') throw error;
+  }
+
+  const existingParent = await nearestExistingParent(path.dirname(normalized));
+  const realParent = await fs.promises.realpath(existingParent);
+  await assertContained(realParent);
+  return normalized;
+}
+
+function statusForError(error, fallbackStatus = 500) {
+  if (typeof error?.statusCode === 'number') return error.statusCode;
+  if (error?.code === 'ENOENT') return 404;
+  if (error?.code === 'EACCES' || error?.code === 'EPERM') return 403;
+  return fallbackStatus;
+}
+
+function classifyFile(targetPath) {
+  const ext = path.extname(targetPath).slice(1).toLowerCase();
+  return {
+    ext,
+    isText: TEXT_EXTENSIONS.has(ext),
+  };
+}
+
+async function handleList(query, sendJson) {
+  try {
+    const targetPath = await resolveSafePath(query.path);
+    const entries = await fs.promises.readdir(targetPath, { withFileTypes: true });
+    const files = await Promise.all(
+      entries.map(async (entry) => {
+        const fullPath = path.join(targetPath, entry.name);
+        const stats = await fs.promises.lstat(fullPath);
+        return {
+          name: entry.name,
+          isDir: stats.isDirectory(),
+          size: stats.size,
+          modTime: stats.mtime.toISOString(),
+        };
+      }),
+    );
+
+    files.sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    sendJson(200, { files, path: targetPath });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to list files';
+    sendJson(statusForError(error), { error: message });
+  }
+}
+
+async function handleRead(query, sendJson) {
+  try {
+    const targetPath = await resolveSafePath(query.path);
+    const stats = await fs.promises.stat(targetPath);
+    if (stats.isDirectory()) {
+      return sendJson(400, { error: 'Cannot read a directory' });
+    }
+    if (stats.size > MAX_READ_BYTES) {
+      return sendJson(413, { error: 'File is too large to read through the filesystem API' });
+    }
+
+    const content = await fs.promises.readFile(targetPath);
+    const { isText } = classifyFile(targetPath);
+
+    if (isText) {
+      sendJson(200, {
+        kind: 'text',
+        path: targetPath,
+        content: content.toString('utf-8'),
+      });
+      return;
+    }
+
+    sendJson(200, {
+      kind: 'binary',
+      path: targetPath,
+      contentBase64: content.toString('base64'),
+      filename: path.basename(targetPath),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to read file';
+    sendJson(statusForError(error), { error: message });
+  }
+}
+
+async function handleWrite(body, sendJson) {
+  try {
+    const targetPath = await resolveSafePath(body.path, { forCreate: true });
+    if (body.content === undefined) {
+      return sendJson(400, { error: 'content is required' });
+    }
+
+    const encoding = body.encoding === 'base64' ? 'base64' : 'utf8';
+    const data = encoding === 'base64'
+      ? Buffer.from(String(body.content), 'base64')
+      : Buffer.from(String(body.content), 'utf-8');
+
+    await fs.promises.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.promises.writeFile(targetPath, data);
+
+    sendJson(200, { success: true, path: targetPath });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to write file';
+    sendJson(statusForError(error), { error: message });
+  }
+}
+
+async function handleDelete(body, sendJson) {
+  try {
+    const targetPath = await resolveSafePath(body.path);
+    await fs.promises.rm(targetPath, { recursive: true, force: true });
+    sendJson(200, { success: true, path: targetPath });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to delete';
+    sendJson(statusForError(error), { error: message });
+  }
+}
+
+async function handleMkdir(body, sendJson) {
+  try {
+    const targetPath = await resolveSafePath(body.path, { forCreate: true });
+    await fs.promises.mkdir(targetPath, { recursive: true, mode: 0o755 });
+    sendJson(200, { success: true, path: targetPath });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to create folder';
+    sendJson(statusForError(error), { error: message });
+  }
+}
+
+async function handleRename(body, sendJson) {
+  try {
+    const oldPath = await resolveSafePath(body.oldPath);
+    const newPath = await resolveSafePath(body.newPath, { forCreate: true });
+    await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
+    await fs.promises.rename(oldPath, newPath);
+    sendJson(200, { success: true, oldPath, newPath });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to rename';
+    sendJson(statusForError(error), { error: message });
+  }
+}
+
+module.exports = {
+  handleDelete,
+  handleList,
+  handleMkdir,
+  handleRead,
+  handleRename,
+  handleWrite,
+  _private: {
+    configuredRootPaths,
+    resolveSafePath,
+  },
+};