neoagent 2.4.1-beta.8 → 2.4.1

package/server/services/mcp/client_support.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const crypto = require('crypto');
+const db = require('../../db/database');
+
+const OAUTH_STATE_TTL_MS = 10 * 60_000;
+
+function hashOAuthState(value) {
+  return crypto.createHash('sha256').update(String(value || '')).digest('hex');
+}
+
+class DBAuthProvider {
+  constructor(serverId, clientId, authServerUrl) {
+    this.serverId = serverId;
+    this.clientId = clientId;
+    this.authServerUrl = authServerUrl;
+  }
+
+  get redirectUrl() {
+    const baseUrl = process.env.PUBLIC_URL || `http://localhost:${process.env.PORT || 3333}`;
+    return `${baseUrl}/api/mcp/oauth/callback`;
+  }
+
+  get clientMetadata() {
+    return { client_id: this.clientId };
+  }
+
+  state() {
+    const state = `${this.serverId}::${crypto.randomBytes(16).toString('hex')}`;
+    const config = this._getConfig();
+    config.auth = config.auth || {};
+    config.auth.oauthStateHash = hashOAuthState(state);
+    config.auth.oauthStateCreatedAt = new Date().toISOString();
+    this._saveConfig(config);
+    return state;
+  }
+
+  clientInformation() {
+    return { client_id: this.clientId };
+  }
+
+  _getConfig() {
+    const row = db.prepare('SELECT config FROM mcp_servers WHERE id = ?').get(this.serverId);
+    return row ? JSON.parse(row.config || '{}') : {};
+  }
+
+  _saveConfig(config) {
+    db.prepare('UPDATE mcp_servers SET config = ? WHERE id = ?')
+      .run(JSON.stringify(config), this.serverId);
+  }
+
+  tokens() {
+    return this._getConfig().auth?.tokens;
+  }
+
+  saveTokens(tokens) {
+    const config = this._getConfig();
+    config.auth = config.auth || {};
+    config.auth.tokens = tokens;
+    this._saveConfig(config);
+  }
+
+  redirectToAuthorization(authorizationUrl) {
+    throw new Error(`OAUTH_REDIRECT:${authorizationUrl.toString()}`);
+  }
+
+  saveCodeVerifier(codeVerifier) {
+    const config = this._getConfig();
+    config.auth = config.auth || {};
+    config.auth.codeVerifier = codeVerifier;
+    this._saveConfig(config);
+  }
+
+  codeVerifier() {
+    return this._getConfig().auth?.codeVerifier;
+  }
+}
+
+function consumeOAuthState(serverId, state) {
+  const row = db.prepare('SELECT config FROM mcp_servers WHERE id = ?').get(serverId);
+  if (!row) return false;
+
+  let config;
+  try {
+    config = JSON.parse(row.config || '{}');
+  } catch {
+    return false;
+  }
+
+  const expectedHash = String(config.auth?.oauthStateHash || '');
+  const createdAt = Date.parse(config.auth?.oauthStateCreatedAt || '');
+  if (
+    !expectedHash
+    || !Number.isFinite(createdAt)
+    || Date.now() - createdAt > OAUTH_STATE_TTL_MS
+    || createdAt > Date.now() + 60_000
+  ) {
+    return false;
+  }
+
+  const actualHash = hashOAuthState(state);
+  const expectedBuffer = Buffer.from(expectedHash, 'hex');
+  const actualBuffer = Buffer.from(actualHash, 'hex');
+  if (
+    expectedBuffer.length !== actualBuffer.length
+    || !crypto.timingSafeEqual(expectedBuffer, actualBuffer)
+  ) {
+    return false;
+  }
+
+  delete config.auth.oauthStateHash;
+  delete config.auth.oauthStateCreatedAt;
+  db.prepare('UPDATE mcp_servers SET config = ? WHERE id = ?')
+    .run(JSON.stringify(config), serverId);
+  return true;
+}
+
+function extractErrorMessage(err) {
+  const raw = err?.message || String(err || 'Unknown error');
+  if (raw.includes('<!doctype') || raw.includes('<html') || raw.includes('<!DOCTYPE')) {
+    const httpMatch = raw.match(/HTTP (\d+)/i);
+    return httpMatch
+      ? `Server returned HTTP ${httpMatch[1]} - the MCP endpoint may be down or misconfigured`
+      : 'Server returned an HTML error page - the MCP endpoint may be down or misconfigured';
+  }
+  if (err?.code === 'ECONNREFUSED' || raw.includes('ECONNREFUSED')) {
+    const addrMatch = raw.match(/connect ECONNREFUSED ([^\s,]+)/);
+    return addrMatch
+      ? `Connection refused at ${addrMatch[1]} - is the MCP server running?`
+      : 'Connection refused - the MCP server is not reachable';
+  }
+  return raw.split('\n')[0].trim();
+}
+
+function normalizeServerId(value) {
+  const text = String(value ?? '').trim();
+  if (!text) return value;
+  const numeric = Number(text);
+  return Number.isSafeInteger(numeric) && numeric > 0 ? numeric : value;
+}
+
+function buildTransportOptions(serverId) {
+  const row = db.prepare('SELECT config FROM mcp_servers WHERE id = ?').get(serverId);
+  const config = row ? JSON.parse(row.config || '{}') : {};
+  const auth = config.auth || {};
+  const transportOptions = {
+    requestInit: { headers: {} },
+    eventSourceInit: { headers: {} },
+  };
+
+  if (auth.type === 'bearer' && auth.token) {
+    const authorization = `Bearer ${auth.token}`;
+    transportOptions.requestInit.headers.Authorization = authorization;
+    transportOptions.eventSourceInit.headers.Authorization = authorization;
+  } else if (auth.type === 'oauth') {
+    transportOptions.authProvider = new DBAuthProvider(
+      serverId,
+      auth.clientId,
+      auth.authServerUrl,
+    );
+  }
+
+  return transportOptions;
+}
+
+module.exports = {
+  DBAuthProvider,
+  buildTransportOptions,
+  consumeOAuthState,
+  extractErrorMessage,
+  normalizeServerId,
+};

package/server/services/mcp/recovery.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const db = require('../../db/database');
+const { normalizeServerId } = require('./client_support');
+
+function scheduleReconnect(manager, serverId, userId, options) {
+  serverId = normalizeServerId(serverId);
+  if (manager._isShuttingDown || manager._reconnectTimers.has(serverId)) return;
+  const server = manager.servers.get(serverId);
+  if (!server || server.status === 'auth_required') return;
+
+  const attempts = Math.max(1, manager._reconnectAttempts.get(serverId) || 1);
+  const delayMs = Math.min(
+    manager._reconnectDelayMs * (2 ** Math.min(attempts - 1, 20)),
+    manager._maxReconnectDelayMs,
+  );
+  server.nextRetryAt = new Date(Date.now() + delayMs).toISOString();
+  manager._setServerStatus(server, 'reconnecting');
+
+  const timer = setTimeout(async () => {
+    manager._reconnectTimers.delete(serverId);
+    if (manager._isShuttingDown) return;
+    const currentServer = manager.servers.get(serverId);
+    if (!currentServer || currentServer.status === 'running') return;
+
+    const row = db.prepare(
+      'SELECT * FROM mcp_servers WHERE id = ? AND enabled = 1'
+    ).get(serverId);
+    if (!row) {
+      await manager.stopServer(serverId);
+      return;
+    }
+
+    try {
+      await manager.startServer(serverId, row.command, row.name, userId, {
+        ...options,
+        _isReconnect: true,
+      });
+      console.log(`[MCP] Reconnected to ${row.name}`);
+    } catch {
+      const failedServer = manager.servers.get(serverId);
+      if (
+        failedServer
+        && failedServer.status !== 'auth_required'
+        && !manager._isShuttingDown
+      ) {
+        scheduleReconnect(manager, serverId, userId, options);
+      }
+    }
+  }, delayMs);
+  timer.unref?.();
+
+  manager._reconnectTimers.set(serverId, timer);
+}
+
+async function loadFromDB(manager, userId) {
+  const servers = db.prepare(
+    'SELECT * FROM mcp_servers WHERE user_id = ? AND enabled = 1'
+  ).all(userId);
+  const results = [];
+
+  for (const serverRow of servers) {
+    try {
+      await manager.startServer(
+        serverRow.id,
+        serverRow.command,
+        serverRow.name,
+        userId,
+        { agentId: serverRow.agent_id },
+      );
+      results.push({
+        id: serverRow.id,
+        name: serverRow.name,
+        status: 'running',
+      });
+    } catch (err) {
+      const message = err.message;
+      console.error(`[MCP] Failed to start "${serverRow.name}":`, message);
+      const server = manager.servers.get(serverRow.id);
+      if (server && server.status !== 'auth_required') {
+        scheduleReconnect(
+          manager,
+          serverRow.id,
+          userId,
+          { agentId: serverRow.agent_id },
+        );
+      }
+      results.push({
+        id: serverRow.id,
+        name: serverRow.name,
+        status: server?.status || 'error',
+        error: message,
+      });
+    }
+  }
+
+  return results;
+}
+
+async function shutdown(manager) {
+  manager._isShuttingDown = true;
+  for (const timer of manager._reconnectTimers.values()) {
+    clearTimeout(timer);
+  }
+  manager._reconnectTimers.clear();
+
+  const stops = Array.from(manager.servers.keys())
+    .map((serverId) => manager.stopServer(serverId));
+  await Promise.allSettled(stops);
+}
+
+module.exports = {
+  loadFromDB,
+  scheduleReconnect,
+  shutdown,
+};

package/server/services/mcp/tool_operations.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const { extractErrorMessage, normalizeServerId } = require('./client_support');
+
+async function listTools(manager, serverId, userId = null) {
+  serverId = normalizeServerId(serverId);
+  const server = manager._getOwnedServer(serverId, userId);
+  if (!server || server.status !== 'running') {
+    throw new Error(`Server ${serverId} not running`);
+  }
+
+  try {
+    const response = await manager._runWithTimeout(
+      () => server.client.listTools(),
+      `Discovering tools from MCP server "${server.name}"`,
+    );
+    server.tools = response.tools || [];
+    server.consecutiveFails = 0;
+    server.lastError = null;
+    manager._reconnectAttempts.delete(serverId);
+    return server.tools;
+  } catch (err) {
+    const message = manager._recordFailure(server, err);
+    manager._scheduleReconnect(serverId, server.userId, { agentId: server.agentId });
+    throw new Error(`Failed to list tools for MCP server "${server.name}": ${message}`);
+  }
+}
+
+async function callTool(manager, serverId, toolName, args = {}, userId = null) {
+  serverId = normalizeServerId(serverId);
+  const server = manager._getOwnedServer(serverId, userId);
+  if (!server) throw new Error(`Server ${serverId} not found`);
+
+  if (server.status !== 'running') {
+    const hint = server.lastError ? ` (${server.lastError})` : '';
+    throw new Error(`MCP server "${server.name}" is not available${hint}`);
+  }
+
+  try {
+    const result = await manager._runWithTimeout(
+      () => server.client.callTool({ name: toolName, arguments: args }),
+      `Calling MCP tool "${toolName}" on "${server.name}"`,
+    );
+    server.consecutiveFails = 0;
+    server.lastError = null;
+    manager._reconnectAttempts.delete(serverId);
+    return result;
+  } catch (err) {
+    const message = extractErrorMessage(err);
+    const consecutiveFails = (server.consecutiveFails || 0) + 1;
+    server.consecutiveFails = consecutiveFails;
+    server.lastError = message;
+
+    if (consecutiveFails >= manager._toolFailureThreshold) {
+      manager._reconnectAttempts.set(serverId, consecutiveFails);
+      server.nextRetryAt = null;
+      manager._setServerStatus(server, 'error');
+      manager._scheduleReconnect(serverId, server.userId, { agentId: server.agentId });
+    }
+
+    throw new Error(`MCP tool "${toolName}" failed: ${message}`);
+  }
+}
+
+async function callToolByName(manager, fullName, args = {}, userId = null, options = {}) {
+  for (const [serverId, server] of manager.servers) {
+    if (userId != null && server.userId !== userId) continue;
+    if (options.agentId && server.agentId && server.agentId !== options.agentId) continue;
+    const prefix = `mcp_${server.slug}_`;
+    if (!fullName.startsWith(prefix)) continue;
+
+    const originalName = fullName.substring(prefix.length);
+    return callTool(manager, serverId, originalName, args, userId);
+  }
+  return null;
+}
+
+function getAllTools(manager, userId = null, options = {}) {
+  const allTools = [];
+  for (const [serverId, server] of manager.servers) {
+    if (userId != null && server.userId !== userId) continue;
+    if (options.agentId && server.agentId && server.agentId !== options.agentId) continue;
+    if (server.status !== 'running') continue;
+    for (const tool of server.tools) {
+      allTools.push({
+        ...tool,
+        name: `mcp_${server.slug}_${tool.name}`,
+        originalName: tool.name,
+        parameters: tool.inputSchema || tool.parameters,
+        serverId,
+      });
+    }
+  }
+  return allTools;
+}
+
+function getStatus(manager, userId = null, options = {}) {
+  const statuses = {};
+  const agentId = options.agentId || options.agent_id || null;
+  for (const [serverId, server] of manager.servers) {
+    if (userId != null && server.userId !== userId) continue;
+    if (agentId && server.agentId && server.agentId !== agentId) continue;
+    statuses[serverId] = {
+      status: server.status,
+      command: server.url,
+      args: [],
+      toolCount: server.tools.length,
+      error: server.lastError || null,
+      consecutiveFails: server.consecutiveFails || 0,
+      nextRetryAt: server.nextRetryAt || null,
+      serverInfo: null,
+    };
+  }
+  return statuses;
+}
+
+module.exports = {
+  callTool,
+  callToolByName,
+  getAllTools,
+  getStatus,
+  listTools,
+};