amalgm 0.1.51 → 0.1.52

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

@@ -1,323 +0,0 @@
-/**
- * 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');
-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,
-  };
-}
-
-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.' },
-        modelSettings: { type: 'object', description: 'Advanced model settings such as effort and fastMode.' },
-        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, modelSettings, 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,
-        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 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' },
-        modelSettings: { type: 'object' },
-        authMethod: { type: 'string' },
-        chatInput: { type: 'object' },
-      },
-      required: ['trigger_id'],
-    },
-    async handler({ trigger_id, name, description, source, event, agent_prompt, enabled, projectPath, harness, model, modelSettings, 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 (modelSettings !== undefined) trigger.modelSettings = modelSettings || 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);
-      activeMemory.ensureConstructMemory({
-        type: 'event',
-        id: trigger.id,
-        name: trigger.name,
-        projectPath: trigger.projectPath,
-      }, { source: 'event:update' });
-      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/tasks/rest.js

@@ -1,110 +0,0 @@
-/**
- * /tasks/* REST routes for the Next.js API to call.
- * Not part of the MCP tool surface — used by the internal UI.
- */
-
-const { loadTasks } = require('./store');
-const taskTools = require('./tools');
-
-const taskToolHandlers = new Map(taskTools.map((tool) => [tool.name, tool.handler]));
-
-function extractText(result) {
-  const entry = Array.isArray(result?.content)
-    ? result.content.find((item) => item && item.type === 'text' && typeof item.text === 'string')
-    : null;
-  return entry?.text || '';
-}
-
-function parseTaskFromText(text) {
-  const jsonStart = typeof text === 'string' ? text.indexOf('{') : -1;
-  if (jsonStart < 0) return null;
-
-  try {
-    return JSON.parse(text.slice(jsonStart));
-  } catch {
-    return null;
-  }
-}
-
-async function callTaskTool(name, args) {
-  const handler = taskToolHandlers.get(name);
-  if (!handler) {
-    throw new Error(`Unknown task tool: ${name}`);
-  }
-
-  const result = await handler(args);
-  const text = extractText(result);
-  return {
-    result,
-    text,
-    isError: Boolean(result?.isError),
-  };
-}
-
-async function handleList(sendJson) {
-  const data = loadTasks();
-  sendJson(200, { tasks: data?.tasks || [] });
-}
-
-async function handleCreate(body, sendJson) {
-  const response = await callTaskTool('scheduled_tasks_create', body);
-  if (response.isError) {
-    return sendJson(400, { error: response.text || 'Failed to create task' });
-  }
-
-  sendJson(200, {
-    ok: true,
-    task: parseTaskFromText(response.text),
-    output: response.result,
-  });
-}
-
-async function handleUpdate(body, sendJson) {
-  const response = await callTaskTool('scheduled_tasks_update', body);
-  if (response.isError) {
-    const status = response.text.startsWith('Task not found:') ? 404 : 400;
-    return sendJson(status, { error: response.text || 'Failed to update task' });
-  }
-
-  sendJson(200, {
-    ok: true,
-    task: parseTaskFromText(response.text),
-    output: response.result,
-  });
-}
-
-async function handleDelete(body, sendJson) {
-  const response = await callTaskTool('scheduled_tasks_delete', body);
-  if (response.isError) {
-    const status = response.text.startsWith('Task not found:') ? 404 : 400;
-    return sendJson(status, { error: response.text || 'Failed to delete task' });
-  }
-
-  sendJson(200, {
-    ok: true,
-    message: response.text,
-    output: response.result,
-  });
-}
-
-async function handleRunNow(body, sendJson) {
-  const response = await callTaskTool('scheduled_tasks_run_now', body);
-  if (response.isError) {
-    const status = response.text.startsWith('Task not found:') ? 404 : 400;
-    return sendJson(status, { error: response.text || 'Failed to run task' });
-  }
-
-  sendJson(200, {
-    ok: true,
-    message: response.text,
-    output: response.result,
-  });
-}
-
-module.exports = {
-  handleList,
-  handleCreate,
-  handleUpdate,
-  handleDelete,
-  handleRunNow,
-};