amalgm 0.0.0 → 0.0.32

package/runtime/scripts/amalgm-mcp/toolbox/runner.js

@@ -0,0 +1,257 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const path = require('path');
+const { errorResult, textResult } = require('../lib/tool-result');
+const { readToolbox } = require('./store');
+
+const TOOLBOX_TOOL_PREFIX = 'toolbox__';
+const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_OUTPUT_BYTES = 512 * 1024;
+const MODEL_UNSUPPORTED_TOP_LEVEL_SCHEMA_KEYS = ['anyOf', 'oneOf', 'allOf', 'not', 'enum'];
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function safeMcpName(value) {
+  return String(value || '')
+    .trim()
+    .replace(/[^A-Za-z0-9_.-]+/g, '_')
+    .replace(/[.-]+/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    || 'tool';
+}
+
+function toolboxMcpToolName(action) {
+  return `${TOOLBOX_TOOL_PREFIX}${safeMcpName(action.id)}`;
+}
+
+function selectedToolIdsForContext(context) {
+  const tools = context?.sessionMetadata?.tools;
+  if (!tools || tools.mode !== 'selected') return null;
+  const selected = Array.isArray(tools.selectedToolIds)
+    ? tools.selectedToolIds
+    : Array.isArray(tools.selected)
+      ? tools.selected
+      : [];
+  return new Set(selected.map((value) => String(value || '').trim()).filter(Boolean));
+}
+
+function portableInputSchema(inputSchema) {
+  if (!isObject(inputSchema) || inputSchema.type !== 'object') {
+    return { type: 'object', properties: {}, additionalProperties: true };
+  }
+  const schema = { ...inputSchema };
+  for (const key of MODEL_UNSUPPORTED_TOP_LEVEL_SCHEMA_KEYS) {
+    delete schema[key];
+  }
+  if (!isObject(schema.properties)) schema.properties = {};
+  return schema;
+}
+
+function enabledToolboxActions(context) {
+  const toolbox = readToolbox();
+  const selectedToolIds = selectedToolIdsForContext(context);
+  return Object.values(toolbox.toolActions || {})
+    .map((action) => {
+      const tool = toolbox.tools?.[action.toolId];
+      return { action, tool };
+    })
+    .filter(({ action, tool }) => {
+      if (!tool || tool.status !== 'enabled' || action.status !== 'enabled') return false;
+      if (tool.origin === 'system') return false;
+      // Remote/local MCP tools are injected as MCP providers. The toolbox MCP
+      // runner is for tools Amalgm itself must execute, currently CLI/API.
+      if (tool.type !== 'cli' && tool.type !== 'api') return false;
+      if (!selectedToolIds) return true;
+      return selectedToolIds.has(tool.id) || selectedToolIds.has(action.id);
+    });
+}
+
+function listToolboxMcpTools(context) {
+  return enabledToolboxActions(context).map(({ action, tool }) => ({
+    name: toolboxMcpToolName(action),
+    description: [
+      action.description || `Run ${tool.name} ${action.name}.`,
+      tool.guide?.kind === 'skill' ? `Guidance skill: ${tool.guide.path}` : null,
+      action.guide?.kind === 'skill' ? `Action skill: ${action.guide.path}` : null,
+    ].filter(Boolean).join('\n'),
+    inputSchema: portableInputSchema(action.inputSchema),
+  }));
+}
+
+function resolveToolboxMcpAction(toolName, context) {
+  return enabledToolboxActions(context)
+    .find(({ action }) => toolboxMcpToolName(action) === toolName) || null;
+}
+
+function collectOutput(child, resolve, reject, timeoutMs) {
+  let stdout = Buffer.alloc(0);
+  let stderr = Buffer.alloc(0);
+  let timedOut = false;
+  const append = (current, chunk) => {
+    const next = Buffer.concat([current, Buffer.from(chunk)]);
+    return next.length > MAX_OUTPUT_BYTES ? next.subarray(next.length - MAX_OUTPUT_BYTES) : next;
+  };
+  const timer = setTimeout(() => {
+    timedOut = true;
+    try { child.kill('SIGTERM'); } catch {}
+    setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch {}
+    }, 1500).unref?.();
+  }, timeoutMs);
+
+  child.stdout.on('data', (chunk) => { stdout = append(stdout, chunk); });
+  child.stderr.on('data', (chunk) => { stderr = append(stderr, chunk); });
+  child.on('error', (err) => {
+    clearTimeout(timer);
+    reject(err);
+  });
+  child.on('close', (code, signal) => {
+    clearTimeout(timer);
+    resolve({
+      code,
+      signal,
+      timedOut,
+      stdout: stdout.toString('utf8'),
+      stderr: stderr.toString('utf8'),
+    });
+  });
+}
+
+function safeEnv(extraEnv) {
+  const env = {};
+  for (const key of ['PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL', 'LANG', 'LC_ALL', 'TERM', 'TMPDIR']) {
+    if (process.env[key]) env[key] = process.env[key];
+  }
+  if (extraEnv && typeof extraEnv === 'object' && !Array.isArray(extraEnv)) {
+    for (const [key, value] of Object.entries(extraEnv)) {
+      if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && value != null) env[key] = String(value);
+    }
+  }
+  return env;
+}
+
+async function runCliTool(tool, action, args) {
+  const source = tool.source || {};
+  const command = String(source.command || '').trim();
+  if (!command) return errorResult(`Tool ${tool.id} has no CLI command configured.`);
+
+  const inputMode = source.inputMode || 'json-stdin';
+  const commandArgs = Array.isArray(source.args) ? [...source.args] : [];
+  if (inputMode === 'argv') {
+    const providedArgs = Array.isArray(args?.args) ? args.args.map(String) : [];
+    commandArgs.push(...providedArgs);
+  } else if (inputMode === 'terminal' && typeof args?.command === 'string') {
+    commandArgs.push(args.command);
+  }
+
+  const child = spawn(command, commandArgs, {
+    cwd: source.cwd || process.cwd(),
+    env: safeEnv(source.env),
+    stdio: ['pipe', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+
+  if (inputMode === 'json-stdin') {
+    child.stdin.end(`${JSON.stringify(args || {})}\n`);
+  } else {
+    child.stdin.end();
+  }
+
+  const result = await new Promise((resolve, reject) => {
+    collectOutput(child, resolve, reject, Number(source.timeoutMs) || DEFAULT_TIMEOUT_MS);
+  });
+
+  const outputMode = source.outputMode || 'text';
+  const stdout = String(result.stdout || '').trim();
+  const stderr = String(result.stderr || '').trim();
+  const statusLine = result.timedOut
+    ? 'timed out'
+    : result.code === 0
+      ? 'completed'
+      : `failed with exit code ${result.code ?? result.signal ?? 'unknown'}`;
+
+  if (result.timedOut || result.code !== 0) {
+    return errorResult([
+      `${tool.name}.${action.name} ${statusLine}.`,
+      stdout ? `stdout:\n${stdout}` : null,
+      stderr ? `stderr:\n${stderr}` : null,
+    ].filter(Boolean).join('\n\n'));
+  }
+
+  if (outputMode === 'json' && stdout) {
+    try {
+      const parsed = JSON.parse(stdout);
+      return {
+        content: [{ type: 'text', text: JSON.stringify(parsed, null, 2) }],
+        structuredContent: parsed,
+      };
+    } catch {
+      // Fall through to text output; many CLIs are aspirationally JSON.
+    }
+  }
+
+  return textResult(stdout || `${tool.name}.${action.name} ${statusLine}.`);
+}
+
+function fillPathParams(template, params = {}) {
+  return String(template || '').replace(/\{([^}]+)\}/g, (_, key) => {
+    const value = params?.[key];
+    return encodeURIComponent(value == null ? '' : String(value));
+  });
+}
+
+async function runApiTool(tool, action, args) {
+  const source = tool.source || {};
+  const sourceAction = action.sourceAction || {};
+  const baseUrl = String(source.baseUrl || '').replace(/\/$/, '');
+  const pathTemplate = sourceAction.path || args?.path || '';
+  const method = String(sourceAction.method || args?.method || 'GET').toUpperCase();
+  if (!baseUrl || !pathTemplate) {
+    return errorResult(`Tool ${tool.id}.${action.name} needs source.baseUrl and sourceAction.path before it can run.`);
+  }
+
+  const url = new URL(`${baseUrl}${fillPathParams(pathTemplate, args?.pathParams || {})}`);
+  for (const [key, value] of Object.entries(args?.query || {})) {
+    if (value != null) url.searchParams.set(key, String(value));
+  }
+
+  const headers = { 'Content-Type': 'application/json' };
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: ['GET', 'HEAD'].includes(method) ? undefined : JSON.stringify(args?.body ?? args ?? {}),
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    return errorResult(`HTTP ${response.status} ${response.statusText}\n\n${text.slice(0, 12000)}`);
+  }
+  try {
+    const parsed = JSON.parse(text);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(parsed, null, 2) }],
+      structuredContent: parsed,
+    };
+  } catch {
+    return textResult(text);
+  }
+}
+
+async function callToolboxMcpTool(toolName, args = {}, context) {
+  const resolved = resolveToolboxMcpAction(toolName, context);
+  if (!resolved) return null;
+  const { tool, action } = resolved;
+  if (tool.type === 'cli') return runCliTool(tool, action, args);
+  if (tool.type === 'api') return runApiTool(tool, action, args);
+  return errorResult(`Tool type ${tool.type} cannot be run through the toolbox runner.`);
+}
+
+module.exports = {
+  TOOLBOX_TOOL_PREFIX,
+  callToolboxMcpTool,
+  listToolboxMcpTools,
+  toolboxMcpToolName,
+};