amalgm 0.0.0 → 0.0.1

package/runtime/scripts/chat-core/tool-shape.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const { compactText, stringifyResult } = require('./tool-display');
+
+function isRecord(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function hostLabel(url) {
+  if (url === undefined || url === null || url === '') return '';
+  try {
+    const host = new URL(String(url)).hostname.replace(/^www\./, '');
+    return host || String(url);
+  } catch {
+    return compactText(url, 80);
+  }
+}
+
+function humanizeToolName(value = '') {
+  const text = String(value || '')
+    .replace(/^mcp__/, '')
+    .replace(/^amalgm[_-]/i, '')
+    .replace(/__/g, ' ')
+    .replace(/[_-]+/g, ' ')
+    .trim();
+  if (!text) return 'Tool';
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+function parseMcpName(name = '') {
+  const text = String(name || '');
+  const mcp = text.match(/^mcp__([^_]+(?:_[^_]+)*)__([\s\S]+)$/);
+  if (mcp) return { server: mcp[1], tool: mcp[2] };
+  const amalgm = text.match(/^amalgm_(.+)$/);
+  if (amalgm) return { server: 'amalgm', tool: amalgm[1] };
+  return null;
+}
+
+function normalizeError(error, fallback = 'Tool failed') {
+  if (!error) return undefined;
+  if (typeof error === 'string') return { message: error };
+  if (isRecord(error)) {
+    const message = error.message || error.error || error.details || fallback;
+    return {
+      message: typeof message === 'string' ? message : stringifyResult(message),
+      ...(error.code ? { code: String(error.code) } : {}),
+      details: error,
+    };
+  }
+  return { message: String(error) || fallback };
+}
+
+function toolKind(name = '', input = {}, metadata = {}) {
+  const clean = String(name || '').toLowerCase();
+  const mcp = metadata.mcp || parseMcpName(name);
+  if (metadata.subagent || clean === 'task' || clean.includes('spawnagent') || clean.includes('collabagent')) return 'subagent';
+  if (clean.includes('todo')) return 'todo';
+  if (clean.includes('question') || clean.includes('askuser')) return 'question';
+  if (clean.includes('toolsearch')) return 'search';
+  if (clean.includes('bash') || clean.includes('command')) return 'bash';
+  if (clean.includes('websearch') || clean === 'websearch') return 'web_search';
+  if (clean.includes('browser') || mcp?.tool?.startsWith?.('browser_')) return 'browser';
+  if (clean.includes('webfetch') || clean === 'webfetch') return 'browser';
+  if (clean.includes('read')) return 'file_read';
+  if (clean.includes('write')) return 'file_write';
+  if (clean.includes('edit') || clean.includes('filechange')) return 'file_edit';
+  if (mcp) return 'mcp';
+  if (input && typeof input === 'object') {
+    if (input.command !== undefined) return 'bash';
+    if (input.url !== undefined) return 'browser';
+    if (input.query !== undefined) return 'web_search';
+    if (input.file_path !== undefined || input.filePath !== undefined || input.path !== undefined) return 'file_read';
+  }
+  return 'unknown';
+}
+
+function titleFromMcp(tool, input = {}) {
+  const name = String(tool || '');
+  const action = name.replace(/^browser_/, '');
+  if (name === 'browser_navigate') return input.url ? `Opening ${hostLabel(input.url)}` : 'Opening browser page';
+  if (name === 'browser_tabs_new') return input.url ? `Opening browser tab ${hostLabel(input.url)}` : 'Opening browser tab';
+  if (name === 'browser_snapshot') return 'Reading browser page';
+  if (name === 'browser_screenshot') return 'Taking browser screenshot';
+  if (name === 'browser_type') return input.text ? `Typing "${compactText(input.text, 60)}"` : 'Typing in browser';
+  if (name === 'browser_click') return 'Clicking in browser';
+  if (name === 'browser_wait_for_load_state') return 'Waiting for page load';
+  if (name === 'artifacts_register') return input.name ? `Registering artifact ${compactText(input.name, 60)}` : 'Registering artifact';
+  if (name === 'artifacts_start') return 'Starting artifact';
+  if (name === 'artifacts_stop') return 'Stopping artifact';
+  if (name === 'artifacts_list') return 'Listing artifacts';
+  if (name === 'agents_list') return 'Listing agents';
+  if (name === 'talk_to_agent') return 'Talking to agent';
+  return humanizeToolName(action || name);
+}
+
+function titleForTool({ name, input = {}, output, error, metadata = {}, fallback } = {}) {
+  if (metadata.actionDescriptor) return compactText(metadata.actionDescriptor, 160);
+  if (metadata.title) return compactText(metadata.title, 160);
+
+  const mcp = metadata.mcp || parseMcpName(name);
+  if (mcp) return titleFromMcp(mcp.tool, input);
+
+  const clean = String(name || '').toLowerCase();
+  if (metadata.action?.type === 'search') {
+    return `Searching ${compactText(metadata.action.query || input.query || 'the web', 80)}`;
+  }
+  if (metadata.action?.type === 'openPage') {
+    const host = hostLabel(metadata.action.url || input.url || input.query);
+    return host ? `Opening ${host}` : 'Opening web page';
+  }
+  if (metadata.action?.type === 'findInPage') {
+    const pattern = metadata.action.pattern || input.pattern;
+    const url = metadata.action.url || input.url;
+    const host = hostLabel(url) || 'current page';
+    return pattern ? `Finding "${compactText(pattern, 60)}" on ${host}` : `Finding text on ${host}`;
+  }
+  if (clean.includes('toolsearch')) {
+    const selected = String(input.query || '').replace(/^select:/i, '').trim();
+    return selected ? `Selecting ${compactText(selected, 80)}` : 'Selecting tool';
+  }
+  if (clean.includes('websearch')) return input.query ? `Searching ${compactText(input.query, 80)}` : 'Searching the web';
+  if (clean.includes('webfetch')) return input.url ? `Opening ${hostLabel(input.url)}` : 'Opening web page';
+  if (clean === 'bash' || clean.includes('command')) return input.command ? `$ ${compactText(input.command, 120)}` : 'Running command';
+  if (clean === 'task' || metadata.subagent) return compactText(input.description || metadata.description || fallback || 'Running subagent', 120);
+  if (error) return normalizeError(error)?.message || 'Tool failed';
+  return compactText(fallback || humanizeToolName(name), 120);
+}
+
+function mcpMetadataFromName(name) {
+  const mcp = parseMcpName(name);
+  return mcp ? { mcp } : {};
+}
+
+module.exports = {
+  hostLabel,
+  humanizeToolName,
+  isRecord,
+  mcpMetadataFromName,
+  normalizeError,
+  parseMcpName,
+  titleForTool,
+  toolKind,
+};

package/runtime/scripts/chat-core/tooling/mcp-bundle.js

@@ -0,0 +1,161 @@
+'use strict';
+
+const { getRuntimeToken } = require('../../runtime-auth');
+
+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) }));
+}
+
+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';
+  return 'http';
+}
+
+function normalizeServer(server) {
+  if (!server || typeof server !== 'object') return null;
+  const name = safeName(server.name);
+  const url = String(server.url || '').trim();
+  if (!name || !url) return null;
+  return {
+    name,
+    type: normalizeType(server.type),
+    url,
+    headers: Array.isArray(server.headers)
+      ? server.headers
+      : recordToHeaderArray(server.headers),
+  };
+}
+
+function localBaseUrl(contract) {
+  return String(contract.localBaseUrl || `http://127.0.0.1:${process.env.CHAT_SERVER_PORT || 8084}`).replace(/\/$/, '');
+}
+
+function amalgmMcpServer(contract) {
+  const port = process.env.AMALGM_MCP_PORT || '8083';
+  const url = process.env.AMALGM_MCP_URL || `http://127.0.0.1:${port}/mcp`;
+  const headers = [
+    { name: 'x-amalgm-runtime-token', value: getRuntimeToken() },
+    { name: 'x-amalgm-session-id', value: contract.sessionId },
+    { name: 'x-amalgm-user-id', value: contract.userId || '' },
+    { name: 'x-amalgm-computer-id', value: contract.computerId || '' },
+  ].filter((h) => h.value);
+  return { name: 'amalgm', type: 'http', url, headers };
+}
+
+function mcpServers(contract) {
+  const byName = new Map();
+  const add = (server) => {
+    const normalized = normalizeServer(server);
+    if (normalized) byName.set(normalized.name, normalized);
+  };
+  add(amalgmMcpServer(contract));
+  for (const server of Array.isArray(contract.mcpServers) ? contract.mcpServers : []) add(server);
+  return [...byName.values()];
+}
+
+function relayUrl(contract, serverName) {
+  return `${localBaseUrl(contract)}/mcp-relay/${encodeURIComponent(contract.sessionId)}/${encodeURIComponent(serverName)}`;
+}
+
+function relayedMcpServers(contract) {
+  const runtimeToken = getRuntimeToken();
+  return mcpServers(contract).map((server) => ({
+    ...server,
+    url: relayUrl(contract, server.name),
+    headers: runtimeToken
+      ? [{ name: 'x-amalgm-runtime-token', value: runtimeToken }]
+      : [],
+  }));
+}
+
+function findMcpRelayTarget(contract, serverName) {
+  const clean = safeName(serverName);
+  return mcpServers(contract).find((server) => server.name === clean) || null;
+}
+
+function toClaudeMcpServers(contract) {
+  const out = {};
+  for (const server of relayedMcpServers(contract)) {
+    out[server.name] = {
+      type: server.type === 'sse' ? 'sse' : 'http',
+      url: server.url,
+      headers: headerArrayToRecord(server.headers),
+      alwaysLoad: server.name === 'amalgm' ? true : undefined,
+    };
+  }
+  return out;
+}
+
+function toOpenCodeMcpConfig(contract) {
+  const out = {};
+  for (const server of relayedMcpServers(contract)) {
+    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 || ''));
+}
+
+function toCodexMcpToml(contract) {
+  const lines = [];
+  const runtimeToken = getRuntimeToken();
+  for (const server of relayedMcpServers(contract)) {
+    lines.push(`[mcp_servers.${server.name}]`);
+    lines.push(`url = ${tomlString(server.url)}`);
+    if (runtimeToken) lines.push('bearer_token_env_var = "AMALGM_RUNTIME_TOKEN"');
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function mcpSummary(contract) {
+  return mcpServers(contract).map((server) => ({
+    name: server.name,
+    type: server.type,
+    url: server.url,
+    hasHeaders: server.headers.length > 0,
+  }));
+}
+
+module.exports = {
+  findMcpRelayTarget,
+  headerArrayToRecord,
+  mcpServers,
+  mcpSummary,
+  relayedMcpServers,
+  safeName,
+  toClaudeMcpServers,
+  toCodexMcpToml,
+  toOpenCodeMcpConfig,
+};

package/runtime/scripts/chat-core/tooling/mcp-relay.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { findMcpRelayTarget, headerArrayToRecord } = require('./mcp-bundle');
+
+const HOP_HEADERS = new Set([
+  'connection',
+  'content-length',
+  'host',
+  'keep-alive',
+  'proxy-authenticate',
+  'proxy-authorization',
+  'te',
+  'trailer',
+  'transfer-encoding',
+  'upgrade',
+]);
+
+function parseMcpRelayPath(pathname) {
+  const parts = String(pathname || '').split('/').filter(Boolean);
+  if (parts[0] !== 'mcp-relay' || !parts[1] || !parts[2]) return null;
+  return {
+    sessionId: decodeURIComponent(parts[1]),
+    serverName: decodeURIComponent(parts[2]),
+  };
+}
+
+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;
+}
+
+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 {}
+  }
+}
+
+module.exports = {
+  forwardMcpRelay,
+  parseMcpRelayPath,
+};