amalgm 0.0.0 → 0.0.1

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

@@ -0,0 +1,165 @@
+/**
+ * /agents/* REST routes (UI-only, not MCP tools).
+ */
+
+const crypto = require('crypto');
+const {
+  loadAgents,
+  saveAgents,
+  getAllAgentsWithBuiltins,
+  resolveAgent,
+} = require('./store');
+const credentialAdapter = require('../../credential-adapter');
+
+function coerceAuthMethodForHarness(harnessId, authMethod) {
+  const supported = credentialAdapter.SUPPORTED_AUTH_BY_HARNESS?.[harnessId] || ['amalgm'];
+  return supported.includes(authMethod) ? authMethod : supported[0] || 'amalgm';
+}
+
+function normalizeStringList(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values
+    .filter((value) => typeof value === 'string')
+    .map((value) => value.trim())
+    .filter(Boolean))];
+}
+
+function normalizeMcpConfig(mcp, mcpAppIds, nativeMcps) {
+  return {
+    inheritAll: mcp?.inheritAll !== false,
+    customServers: Array.isArray(mcp?.customServers) ? mcp.customServers : [],
+    appIds: normalizeStringList(mcp?.appIds ?? mcpAppIds),
+    nativeMcps: normalizeStringList(mcp?.nativeMcps ?? nativeMcps),
+  };
+}
+
+async function handleList(sendJson) {
+  sendJson(200, { agents: getAllAgentsWithBuiltins() });
+}
+
+async function handleGet(body, sendJson) {
+  const { agent_id } = body;
+  const agent = resolveAgent(agent_id);
+  if (!agent) return sendJson(404, { error: `Agent not found: ${agent_id}` });
+  sendJson(200, { agent });
+}
+
+async function handleCreate(body, sendJson) {
+  const {
+    name,
+    description,
+    baseHarnessId,
+    baseModelId,
+    systemPrompt,
+    files,
+    skills,
+    mcpAppIds,
+    nativeMcps,
+    mcp,
+    authMethod,
+  } = body;
+  if (!name || !name.trim()) return sendJson(400, { error: 'name is required' });
+  if (!baseHarnessId) return sendJson(400, { error: 'baseHarnessId is required' });
+
+  const data = loadAgents();
+  if (data.agents.some((a) => a.name.toLowerCase() === name.trim().toLowerCase())) {
+    return sendJson(400, { error: `An agent named "${name.trim()}" already exists` });
+  }
+
+  const agent = {
+    id: `custom-${crypto.randomUUID()}`,
+    name: name.trim(),
+    description: description || '',
+    baseHarnessId,
+    baseModelId: baseModelId || '',
+    systemPrompt: systemPrompt || '',
+    files: normalizeStringList(files),
+    skills: normalizeStringList(skills),
+    mcpAppIds: normalizeStringList(mcpAppIds),
+    nativeMcps: normalizeStringList(nativeMcps),
+    mcp: normalizeMcpConfig(mcp, mcpAppIds, nativeMcps),
+    authMethod: coerceAuthMethodForHarness(baseHarnessId, authMethod),
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+  data.agents.push(agent);
+  saveAgents(data);
+  console.log(`[AmalgmMCP] Created agent: ${agent.id} (${agent.name})`);
+  sendJson(200, { ok: true, agent });
+}
+
+async function handleUpdate(body, sendJson) {
+  const { agent_id, ...updates } = body;
+  if (!agent_id) return sendJson(400, { error: 'agent_id is required' });
+  const data = loadAgents();
+  const agent = data.agents.find((a) => a.id === agent_id);
+  if (!agent) return sendJson(404, { error: `Agent not found: ${agent_id}` });
+
+  if (
+    updates.name &&
+    data.agents.some(
+      (a) => a.id !== agent_id && a.name.toLowerCase() === updates.name.trim().toLowerCase(),
+    )
+  ) {
+    return sendJson(400, { error: `An agent named "${updates.name.trim()}" already exists` });
+  }
+
+  const allowedFields = [
+    'name',
+    'description',
+    'baseHarnessId',
+    'baseModelId',
+    'systemPrompt',
+    'files',
+    'skills',
+    'mcpAppIds',
+    'nativeMcps',
+    'mcp',
+    'authMethod',
+  ];
+  for (const field of allowedFields) {
+    if (updates[field] === undefined) continue;
+
+    if (field === 'files' || field === 'skills' || field === 'mcpAppIds' || field === 'nativeMcps') {
+      agent[field] = normalizeStringList(updates[field]);
+      continue;
+    }
+
+    if (field === 'mcp') {
+      agent.mcp = normalizeMcpConfig(
+        updates.mcp,
+        updates.mcpAppIds ?? agent.mcpAppIds,
+        updates.nativeMcps ?? agent.nativeMcps,
+      );
+      continue;
+    }
+
+    if (field === 'authMethod') {
+      agent.authMethod = coerceAuthMethodForHarness(agent.baseHarnessId, updates.authMethod);
+      continue;
+    }
+
+    agent[field] = updates[field];
+  }
+  agent.authMethod = coerceAuthMethodForHarness(agent.baseHarnessId, agent.authMethod);
+  agent.mcpAppIds = normalizeStringList(agent.mcp?.appIds ?? agent.mcpAppIds);
+  agent.nativeMcps = normalizeStringList(agent.mcp?.nativeMcps ?? agent.nativeMcps);
+  agent.updatedAt = new Date().toISOString();
+  saveAgents(data);
+  console.log(`[AmalgmMCP] Updated agent: ${agent.id} (${agent.name})`);
+  sendJson(200, { ok: true, agent });
+}
+
+async function handleDelete(body, sendJson) {
+  const { agent_id } = body;
+  if (!agent_id) return sendJson(400, { error: 'agent_id is required' });
+  const data = loadAgents();
+  const idx = data.agents.findIndex((a) => a.id === agent_id);
+  if (idx === -1) return sendJson(404, { error: `Agent not found: ${agent_id}` });
+  const deleted = data.agents.splice(idx, 1)[0];
+  saveAgents(data);
+  console.log(`[AmalgmMCP] Deleted agent: ${agent_id} (${deleted.name})`);
+  sendJson(200, { ok: true, deleted });
+}
+
+module.exports = { handleList, handleGet, handleCreate, handleUpdate, handleDelete };

package/runtime/scripts/amalgm-mcp/agents/store.js

@@ -0,0 +1,153 @@
+/**
+ * Agents storage — ~/.amalgm/agents.json + built-in defaults.
+ *
+ * Built-ins are compile-time (claude_code, codex, opencode, pi, amp, cursor). Custom agents
+ * persist to agents.json with id prefix "custom-".
+ */
+
+const path = require('path');
+const { AGENTS_FILE, AGENT_CONVOS_DIR, STORAGE_DIR } = require('../config');
+const {
+  ensureDir,
+  readJson,
+  writeJsonAtomic,
+  appendJsonl,
+  tailJsonl,
+} = require('../lib/storage');
+
+const BUILTIN_AGENTS = [
+  {
+    id: 'claude_code',
+    name: 'Claude Code',
+    description:
+      'Anthropic Claude agent — general-purpose coding, research, and reasoning',
+    baseHarnessId: 'claude_code',
+    baseModelId: 'anthropic/claude-opus-4.7',
+    systemPrompt: '',
+    mcp: { inheritAll: true, customServers: [] },
+    builtin: true,
+  },
+  {
+    id: 'codex',
+    name: 'Codex',
+    description: 'OpenAI Codex agent — code generation and analysis',
+    baseHarnessId: 'codex',
+    baseModelId: 'openai/gpt-5.4-thinking-xhigh',
+    systemPrompt: '',
+    mcp: { inheritAll: true, customServers: [] },
+    builtin: true,
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    description: 'Open-source agent — multi-provider coding assistant',
+    baseHarnessId: 'opencode',
+    baseModelId: 'opencode-moonshotai-kimi-k2.5',
+    systemPrompt: '',
+    mcp: { inheritAll: true, customServers: [] },
+    builtin: true,
+  },
+  {
+    id: 'pi',
+    name: 'Pi',
+    description: 'Pi agent — multi-provider coding assistant',
+    baseHarnessId: 'pi',
+    baseModelId: 'pi-anthropic-claude-sonnet-4.6',
+    systemPrompt: '',
+    mcp: { inheritAll: true, customServers: [] },
+    builtin: true,
+  },
+  {
+    id: 'amp',
+    name: 'Amp',
+    description: 'Sourcegraph Amp agent — terminal-auth coding assistant',
+    baseHarnessId: 'amp',
+    baseModelId: 'amp-default',
+    systemPrompt: '',
+    mcp: { inheritAll: true, customServers: [] },
+    builtin: true,
+  },
+  {
+    id: 'cursor',
+    name: 'Cursor',
+    description: 'Cursor Agent CLI — account-auth coding assistant',
+    baseHarnessId: 'cursor',
+    baseModelId: 'cursor/composer-2-fast',
+    systemPrompt: '',
+    mcp: { inheritAll: true, customServers: [] },
+    builtin: true,
+  },
+];
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function normalizeConversationId(value) {
+  const clean = String(value || '').trim();
+  return UUID_RE.test(clean) ? clean : null;
+}
+
+function conversationLogPath(sessionId) {
+  const conversationId = normalizeConversationId(sessionId);
+  if (!conversationId) throw new Error('conversation_id must be a UUID');
+  return path.join(AGENT_CONVOS_DIR, `${conversationId}.jsonl`);
+}
+
+function ensureAgentsDirs() {
+  ensureDir(STORAGE_DIR);
+  ensureDir(AGENT_CONVOS_DIR);
+  if (!readJson(AGENTS_FILE, null)) writeJsonAtomic(AGENTS_FILE, { version: 1, agents: [] });
+}
+
+function loadAgents() {
+  return readJson(AGENTS_FILE, { version: 1, agents: [] });
+}
+
+function saveAgents(data) {
+  writeJsonAtomic(AGENTS_FILE, data);
+}
+
+function getAllAgentsWithBuiltins() {
+  const data = loadAgents();
+  return [...BUILTIN_AGENTS, ...data.agents];
+}
+
+function resolveAgent(agentId) {
+  const builtin = BUILTIN_AGENTS.find((a) => a.id === agentId);
+  if (builtin) return builtin;
+  const data = loadAgents();
+  return data.agents.find((a) => a.id === agentId) || null;
+}
+
+function normalizeAgentLookup(value) {
+  return String(value || '').trim().toLowerCase().replace(/[\s_-]+/g, '');
+}
+
+function resolveAgentByNameOrId(value) {
+  const clean = normalizeAgentLookup(value);
+  if (!clean) return null;
+  return getAllAgentsWithBuiltins().find((agent) => (
+    normalizeAgentLookup(agent.id) === clean ||
+    normalizeAgentLookup(agent.name) === clean
+  )) || null;
+}
+
+function appendAgentConvoLog(sessionId, entry) {
+  appendJsonl(conversationLogPath(sessionId), entry);
+}
+
+function readAgentConvoLog(sessionId, limit = 50) {
+  return tailJsonl(conversationLogPath(sessionId), limit);
+}
+
+module.exports = {
+  BUILTIN_AGENTS,
+  ensureAgentsDirs,
+  loadAgents,
+  saveAgents,
+  getAllAgentsWithBuiltins,
+  resolveAgent,
+  resolveAgentByNameOrId,
+  normalizeConversationId,
+  appendAgentConvoLog,
+  readAgentConvoLog,
+};