@amalgm/chat 0.1.2 → 0.2.1

package/host/tooling/mcp-bundle.js

@@ -0,0 +1,214 @@
+/** Exact prepared MCP-server projection for every native adapter. */
+
+/** Engine `runtime-auth.js getRuntimeToken`, byte-faithful. */
+function getRuntimeToken() {
+  return String(process.env.AMALGM_RUNTIME_TOKEN || '').trim();
+}
+
+export function headerArrayToRecord(headers) {
+  const out = {};
+  for (const header of Array.isArray(headers) ? headers : []) {
+    const name = String(header?.name || '').trim();
+    const value = String(header?.value || '');
+    if (name) out[name] = value;
+  }
+  return out;
+}
+
+function recordToHeaderArray(headers) {
+  if (!headers || typeof headers !== 'object') return [];
+  return Object.entries(headers)
+    .filter(([name, value]) => name && value != null)
+    .map(([name, value]) => ({ name, value: String(value) }));
+}
+
+export function safeName(name) {
+  return String(name || '')
+    .trim()
+    .replace(/[^A-Za-z0-9_.-]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    || 'mcp';
+}
+
+function normalizeType(type) {
+  const clean = String(type || '').toLowerCase();
+  if (clean === 'sse') return 'sse';
+  if (clean === 'stdio') return 'stdio';
+  return 'http';
+}
+
+export class InvalidMcpServerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'InvalidMcpServerError';
+    this.code = 'INVALID_MCP_SERVER';
+  }
+}
+
+function normalizeServer(server) {
+  if (!server || typeof server !== 'object') {
+    throw new InvalidMcpServerError('MCP server must be an object');
+  }
+  const name = safeName(server.name);
+  const type = normalizeType(server.type);
+  if (type === 'stdio') {
+    const command = String(server.command || '').trim();
+    if (!command) throw new InvalidMcpServerError(`${name} stdio MCP server requires command`);
+    const args = Array.isArray(server.args) ? server.args.map((arg) => String(arg)) : [];
+    const env = Array.isArray(server.env)
+      ? server.env.map((entry) => ({ name: String(entry?.name || ''), value: String(entry?.value || '') }))
+      : recordToHeaderArray(server.env);
+    if (env.some((entry) => !entry.name)) {
+      throw new InvalidMcpServerError(`${name} stdio MCP server has an empty environment variable name`);
+    }
+    return { name, type, command, args, env };
+  }
+  const url = String(server.url || '').trim();
+  if (!url) throw new InvalidMcpServerError(`${name} ${type} MCP server requires url`);
+  return {
+    name,
+    type,
+    url,
+    headers: Array.isArray(server.headers)
+      ? server.headers
+      : recordToHeaderArray(server.headers),
+  };
+}
+
+function localBaseUrl(contract) {
+  const value = String(contract.localBaseUrl || '').trim();
+  if (!value) throw new InvalidMcpServerError('Remote MCP servers require localBaseUrl');
+  return value.replace(/\/$/, '');
+}
+
+export function mcpServers(contract) {
+  const byName = new Map();
+  const add = (server) => {
+    const normalized = normalizeServer(server);
+    byName.set(normalized.name, normalized);
+  };
+  for (const server of Array.isArray(contract.mcpServers) ? contract.mcpServers : []) add(server);
+  return [...byName.values()];
+}
+
+function relayUrl(contract, serverName) {
+  return `${localBaseUrl(contract)}/chat/mcp/${encodeURIComponent(contract.sessionId)}/${encodeURIComponent(serverName)}`;
+}
+
+export function relayedMcpServers(contract) {
+  const runtimeToken = getRuntimeToken();
+  return mcpServers(contract).map((server) => server.type === 'stdio'
+    ? server
+    : ({
+        ...server,
+        url: relayUrl(contract, server.name),
+        headers: runtimeToken
+          ? [{ name: 'x-amalgm-runtime-token', value: runtimeToken }]
+          : [],
+      }));
+}
+
+export function findMcpRelayTarget(contract, serverName) {
+  const clean = safeName(serverName);
+  return mcpServers(contract).find((server) => server.name === clean && server.type !== 'stdio') || null;
+}
+
+export function toClaudeMcpServers(contract) {
+  const out = {};
+  for (const server of relayedMcpServers(contract)) {
+    if (server.type === 'stdio') {
+      out[server.name] = {
+        type: 'stdio',
+        command: server.command,
+        args: server.args,
+        env: headerArrayToRecord(server.env),
+      };
+      continue;
+    }
+    out[server.name] = {
+      type: server.type === 'sse' ? 'sse' : 'http',
+      url: server.url,
+      headers: headerArrayToRecord(server.headers),
+      alwaysLoad: server.name === 'amalgm' ? true : undefined,
+    };
+  }
+  return out;
+}
+
+export function toOpenCodeMcpConfig(contract) {
+  const out = {};
+  for (const server of relayedMcpServers(contract)) {
+    if (server.type === 'stdio') {
+      out[server.name] = {
+        type: 'local',
+        command: [server.command, ...server.args],
+        enabled: true,
+        environment: headerArrayToRecord(server.env),
+        timeout: 15000,
+      };
+      continue;
+    }
+    out[server.name] = {
+      type: 'remote',
+      url: server.url,
+      enabled: true,
+      headers: headerArrayToRecord(server.headers),
+      oauth: false,
+      timeout: 15000,
+    };
+  }
+  return out;
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value || ''));
+}
+
+export function toCodexMcpToml(contract) {
+  const lines = [];
+  const runtimeToken = getRuntimeToken();
+  for (const server of relayedMcpServers(contract)) {
+    lines.push(`[mcp_servers.${server.name}]`);
+    if (server.type === 'stdio') {
+      lines.push(`command = ${tomlString(server.command)}`);
+      if (server.args.length) lines.push(`args = ${JSON.stringify(server.args)}`);
+      if (server.env.length) {
+        lines.push('');
+        lines.push(`[mcp_servers.${server.name}.env]`);
+        for (const entry of server.env) lines.push(`${tomlString(entry.name)} = ${tomlString(entry.value)}`);
+      }
+    } else {
+      lines.push(`url = ${tomlString(server.url)}`);
+      if (runtimeToken) lines.push('bearer_token_env_var = "AMALGM_RUNTIME_TOKEN"');
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+export function mcpSummary(contract) {
+  return mcpServers(contract).map((server) => ({
+    name: server.name,
+    type: server.type,
+    ...(server.type === 'stdio'
+      ? { command: server.command, hasEnvironment: server.env.length > 0 }
+      : { url: server.url, hasHeaders: server.headers.length > 0 }),
+  }));
+}
+
+/** Official ACP MCP-server projection used by Cursor and generic ACP agents. */
+export function toAcpMcpServers(contract) {
+  return relayedMcpServers(contract).map((server) => server.type === 'stdio'
+    ? {
+        name: server.name,
+        command: server.command,
+        args: [...server.args],
+        env: server.env.map((entry) => ({ ...entry })),
+      }
+    : {
+        type: server.type,
+        name: server.name,
+        url: server.url,
+        headers: server.headers.map((header) => ({ ...header })),
+      });
+}

package/host/tooling/mcp-relay.js

@@ -0,0 +1,83 @@
+/** Session-bound relay that keeps remote MCP credentials out of provider config. */
+
+import { findMcpRelayTarget, headerArrayToRecord } from './mcp-bundle.js';
+
+const HOP_HEADERS = new Set([
+  'connection',
+  'content-length',
+  'host',
+  'keep-alive',
+  'proxy-authenticate',
+  'proxy-authorization',
+  'te',
+  'trailer',
+  'transfer-encoding',
+  'upgrade',
+]);
+
+function copyRequestHeaders(req, extraHeaders) {
+  const headers = {};
+  for (const [name, value] of Object.entries(req.headers || {})) {
+    const lower = name.toLowerCase();
+    if (HOP_HEADERS.has(lower)) continue;
+    if (lower === 'authorization') continue;
+    headers[name] = Array.isArray(value) ? value.join(', ') : String(value);
+  }
+  Object.assign(headers, extraHeaders);
+  return headers;
+}
+
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(Buffer.from(chunk));
+  return chunks.length ? Buffer.concat(chunks) : null;
+}
+
+export async function forwardMcpRelay({ req, res, contract, serverName, search = '' }) {
+  const target = findMcpRelayTarget(contract, serverName);
+  if (!target) {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Unknown MCP server', serverName }));
+    return;
+  }
+
+  const upstream = `${target.url}${search || ''}`;
+  const extraHeaders = {
+    ...headerArrayToRecord(target.headers),
+    'x-amalgm-session-id': contract.sessionId,
+    'x-amalgm-user-id': contract.userId || '',
+    'x-amalgm-computer-id': contract.computerId || '',
+  };
+  for (const key of Object.keys(extraHeaders)) {
+    if (!extraHeaders[key]) delete extraHeaders[key];
+  }
+
+  const body = ['GET', 'HEAD'].includes(req.method) ? undefined : await readBody(req);
+  const response = await fetch(upstream, {
+    method: req.method,
+    headers: copyRequestHeaders(req, extraHeaders),
+    body,
+    redirect: 'manual',
+  });
+
+  const headers = {};
+  response.headers.forEach((value, name) => {
+    if (!HOP_HEADERS.has(name.toLowerCase())) headers[name] = value;
+  });
+  res.writeHead(response.status, headers);
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) res.write(Buffer.from(value));
+    }
+    res.end();
+  } catch (err) {
+    try { res.destroy(err); } catch {}
+  }
+}