snow-flow 1.4.49 → 2.0.0

package/src/utils/logger.ts

@@ -0,0 +1,60 @@
+/**
+ * Logger utility for ServiceNow agents
+ */
+
+import winston from 'winston';
+import path from 'path';
+
+export class Logger {
+  private logger: winston.Logger;
+
+  constructor(agentName: string) {
+    const logDir = path.join(process.cwd(), 'logs');
+    
+    this.logger = winston.createLogger({
+      level: process.env.LOG_LEVEL || 'info',
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.errors({ stack: true }),
+        winston.format.json()
+      ),
+      defaultMeta: { agent: agentName },
+      transports: [
+        // Console transport
+        new winston.transports.Console({
+          format: winston.format.combine(
+            winston.format.colorize(),
+            winston.format.simple()
+          )
+        }),
+        // File transport
+        new winston.transports.File({
+          filename: path.join(logDir, `${agentName}-error.log`),
+          level: 'error'
+        }),
+        new winston.transports.File({
+          filename: path.join(logDir, `${agentName}.log`)
+        })
+      ]
+    });
+  }
+
+  info(message: string, meta?: any): void {
+    this.logger.info(message, meta);
+  }
+
+  error(message: string, meta?: any): void {
+    this.logger.error(message, meta);
+  }
+
+  warn(message: string, meta?: any): void {
+    this.logger.warn(message, meta);
+  }
+
+  debug(message: string, meta?: any): void {
+    this.logger.debug(message, meta);
+  }
+}
+
+// Create a default logger instance
+export const logger = new Logger('snow-flow');

package/src/utils/mcp-auth-middleware.ts

@@ -0,0 +1,262 @@
+/**
+ * Centralized MCP Authentication Middleware
+ * Handles ServiceNow OAuth authentication across all MCP servers
+ */
+
+import { ServiceNowOAuth } from './snow-oauth.js';
+import { mcpConfig } from './mcp-config-manager.js';
+import { Logger } from './logger.js';
+
+export interface AuthenticationResult {
+  success: boolean;
+  token?: string;
+  error?: string;
+  needsReauth?: boolean;
+}
+
+export class MCPAuthenticationMiddleware {
+  private static instance: MCPAuthenticationMiddleware;
+  private oauth: ServiceNowOAuth;
+  private logger: Logger;
+  private lastAuthCheck: Date | null = null;
+  private authCheckInterval: number = 5 * 60 * 1000; // 5 minutes
+
+  private constructor() {
+    this.logger = new Logger('MCPAuthMiddleware');
+    this.oauth = new ServiceNowOAuth();
+  }
+
+  public static getInstance(): MCPAuthenticationMiddleware {
+    if (!MCPAuthenticationMiddleware.instance) {
+      MCPAuthenticationMiddleware.instance = new MCPAuthenticationMiddleware();
+    }
+    return MCPAuthenticationMiddleware.instance;
+  }
+
+  /**
+   * Ensure authentication is valid before MCP operations
+   */
+  async ensureAuthenticated(): Promise<AuthenticationResult> {
+    try {
+      // Check if we need to refresh authentication
+      if (this.shouldCheckAuth()) {
+        this.logger.debug('Checking authentication status...');
+        
+        const isAuthenticated = await this.oauth.isAuthenticated();
+        if (!isAuthenticated) {
+          this.logger.warn('Authentication expired or invalid');
+          return {
+            success: false,
+            error: 'ServiceNow authentication expired. Please run "snow-flow auth login" again.',
+            needsReauth: true
+          };
+        }
+
+        this.lastAuthCheck = new Date();
+      }
+
+      // Get current token
+      const token = await this.oauth.getAccessToken();
+      if (!token) {
+        return {
+          success: false,
+          error: 'No access token available. Please authenticate first.',
+          needsReauth: true
+        };
+      }
+
+      return {
+        success: true,
+        token
+      };
+
+    } catch (error) {
+      this.logger.error('Authentication check failed:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Authentication check failed',
+        needsReauth: true
+      };
+    }
+  }
+
+  /**
+   * Check if authentication status should be verified
+   */
+  private shouldCheckAuth(): boolean {
+    if (!this.lastAuthCheck) return true;
+    
+    const timeSinceLastCheck = Date.now() - this.lastAuthCheck.getTime();
+    return timeSinceLastCheck > this.authCheckInterval;
+  }
+
+  /**
+   * Handle authentication errors with automatic retry
+   */
+  async handleAuthError(error: any): Promise<AuthenticationResult> {
+    this.logger.warn('Handling authentication error:', error);
+
+    // Check if this is an authentication-related error
+    if (this.isAuthError(error)) {
+      // Try to refresh token
+      try {
+        const credentials = await this.oauth.loadCredentials();
+        if (credentials) {
+          const refreshResult = await this.oauth.refreshAccessToken(credentials);
+          if (refreshResult.success) {
+            this.logger.info('Token refreshed successfully');
+            return {
+              success: true,
+              token: refreshResult.accessToken
+            };
+          }
+        }
+      } catch (refreshError) {
+        this.logger.error('Token refresh failed:', refreshError);
+      }
+
+      // If refresh failed, require re-authentication
+      return {
+        success: false,
+        error: 'Authentication failed. Please run "snow-flow auth login" again.',
+        needsReauth: true
+      };
+    }
+
+    // Not an auth error, return original error
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+
+  /**
+   * Check if an error is authentication-related
+   */
+  private isAuthError(error: any): boolean {
+    if (!error) return false;
+
+    const errorMessage = error.message || error.toString() || '';
+    const errorCode = error.status || error.code || 0;
+
+    // Check for common authentication error patterns
+    const authErrorPatterns = [
+      'unauthorized',
+      'authentication',
+      'expired',
+      'invalid token',
+      'access denied',
+      'forbidden'
+    ];
+
+    const isAuthMessage = authErrorPatterns.some(pattern => 
+      errorMessage.toLowerCase().includes(pattern)
+    );
+
+    const isAuthCode = [401, 403].includes(errorCode);
+
+    return isAuthMessage || isAuthCode;
+  }
+
+  /**
+   * Get ServiceNow instance information
+   */
+  async getInstanceInfo(): Promise<{ instance: string; authenticated: boolean }> {
+    const config = mcpConfig.getServiceNowConfig();
+    const authenticated = await this.oauth.isAuthenticated();
+    
+    return {
+      instance: config.instanceUrl || 'Not configured',
+      authenticated
+    };
+  }
+
+  /**
+   * Wrapper for MCP operations with authentication
+   */
+  async withAuth<T>(operation: (token: string) => Promise<T>): Promise<T> {
+    const authResult = await this.ensureAuthenticated();
+    
+    if (!authResult.success) {
+      throw new Error(authResult.error || 'Authentication failed');
+    }
+
+    try {
+      return await operation(authResult.token!);
+    } catch (error) {
+      // Handle potential authentication errors during operation
+      const authErrorResult = await this.handleAuthError(error);
+      
+      if (authErrorResult.needsReauth) {
+        throw new Error(authErrorResult.error || 'Authentication required');
+      }
+      
+      // If we successfully refreshed the token, retry the operation
+      if (authErrorResult.success && authErrorResult.token) {
+        return await operation(authErrorResult.token);
+      }
+      
+      // Re-throw original error if not auth-related
+      throw error;
+    }
+  }
+
+  /**
+   * Get authentication headers for HTTP requests
+   */
+  async getAuthHeaders(): Promise<{ [key: string]: string }> {
+    const authResult = await this.ensureAuthenticated();
+    
+    if (!authResult.success) {
+      throw new Error(authResult.error || 'Authentication failed');
+    }
+
+    return {
+      'Authorization': `Bearer ${authResult.token}`,
+      'Content-Type': 'application/json',
+      'Accept': 'application/json'
+    };
+  }
+
+  /**
+   * Force authentication refresh
+   */
+  async forceRefresh(): Promise<AuthenticationResult> {
+    this.logger.info('Forcing authentication refresh...');
+    this.lastAuthCheck = null;
+    
+    try {
+      const credentials = await this.oauth.loadCredentials();
+      if (credentials) {
+        const refreshResult = await this.oauth.refreshAccessToken(credentials);
+        if (refreshResult.success) {
+          return {
+            success: true,
+            token: refreshResult.accessToken
+          };
+        } else {
+          return {
+            success: false,
+            error: 'Token refresh failed',
+            needsReauth: true
+          };
+        }
+      } else {
+        return {
+          success: false,
+          error: 'No credentials available',
+          needsReauth: true
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Refresh failed',
+        needsReauth: true
+      };
+    }
+  }
+}
+
+// Export singleton instance
+export const mcpAuth = MCPAuthenticationMiddleware.getInstance();

package/src/utils/mcp-config-manager.ts

@@ -0,0 +1,270 @@
+/**
+ * Centralized MCP Configuration Manager
+ * Handles dynamic configuration loading for all MCP servers
+ */
+
+import { config } from 'dotenv';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+import { Logger } from './logger.js';
+
+// Load environment variables
+config();
+
+export interface MCPConfig {
+  servicenow: {
+    instanceUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+    oauthRedirectUri?: string;
+    maxRetries?: number;
+    timeout?: number;
+  };
+  neo4j?: {
+    uri?: string;
+    username?: string;
+    password?: string;
+    database?: string;
+  };
+  memory: {
+    provider: 'file' | 'neo4j' | 'redis';
+    path?: string;
+    connectionString?: string;
+    maxSize?: number;
+    ttl?: number;
+  };
+  performance: {
+    connectionPoolSize?: number;
+    requestTimeout?: number;
+    retryAttempts?: number;
+    cacheEnabled?: boolean;
+    cacheTtl?: number;
+  };
+  logging: {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    enableFileLogging?: boolean;
+    logPath?: string;
+  };
+}
+
+export class MCPConfigManager {
+  private static instance: MCPConfigManager;
+  private config: MCPConfig;
+  private logger: Logger;
+
+  private constructor() {
+    this.logger = new Logger('MCPConfigManager');
+    this.config = this.loadConfiguration();
+  }
+
+  public static getInstance(): MCPConfigManager {
+    if (!MCPConfigManager.instance) {
+      MCPConfigManager.instance = new MCPConfigManager();
+    }
+    return MCPConfigManager.instance;
+  }
+
+  /**
+   * Load configuration from environment variables and config files
+   */
+  private loadConfiguration(): MCPConfig {
+    const baseConfig: MCPConfig = {
+      servicenow: {
+        instanceUrl: process.env.SERVICENOW_INSTANCE_URL || process.env.SERVICENOW_INSTANCE,
+        clientId: process.env.SERVICENOW_CLIENT_ID,
+        clientSecret: process.env.SERVICENOW_CLIENT_SECRET,
+        oauthRedirectUri: process.env.SERVICENOW_OAUTH_REDIRECT_URI || 'http://localhost:8080/auth/callback',
+        maxRetries: parseInt(process.env.SERVICENOW_MAX_RETRIES || '3'),
+        timeout: parseInt(process.env.SERVICENOW_TIMEOUT || '30000')
+      },
+      neo4j: {
+        uri: process.env.NEO4J_URI || process.env.NEO4J_URL,
+        username: process.env.NEO4J_USERNAME || process.env.NEO4J_USER,
+        password: process.env.NEO4J_PASSWORD || process.env.NEO4J_PASS,
+        database: process.env.NEO4J_DATABASE || 'neo4j'
+      },
+      memory: {
+        provider: (process.env.MEMORY_PROVIDER as 'file' | 'neo4j' | 'redis') || 'file',
+        path: process.env.MEMORY_PATH || join(process.env.SNOW_FLOW_HOME || join(os.homedir(), '.snow-flow'), 'memory'),
+        connectionString: process.env.MEMORY_CONNECTION_STRING,
+        maxSize: parseInt(process.env.MEMORY_MAX_SIZE || '1000'),
+        ttl: parseInt(process.env.MEMORY_TTL || '86400') // 24 hours
+      },
+      performance: {
+        connectionPoolSize: parseInt(process.env.CONNECTION_POOL_SIZE || '10'),
+        requestTimeout: parseInt(process.env.REQUEST_TIMEOUT || '30000'),
+        retryAttempts: parseInt(process.env.RETRY_ATTEMPTS || '3'),
+        cacheEnabled: process.env.CACHE_ENABLED !== 'false',
+        cacheTtl: parseInt(process.env.CACHE_TTL || '300') // 5 minutes
+      },
+      logging: {
+        level: (process.env.LOG_LEVEL as 'debug' | 'info' | 'warn' | 'error') || 'info',
+        enableFileLogging: process.env.ENABLE_FILE_LOGGING === 'true',
+        logPath: process.env.LOG_PATH || join(process.env.SNOW_FLOW_HOME || join(os.homedir(), '.snow-flow'), 'logs')
+      }
+    };
+
+    // Try to load from config file if it exists
+    const configPath = join(process.env.SNOW_FLOW_HOME || join(os.homedir(), '.snow-flow'), 'config.json');
+    if (existsSync(configPath)) {
+      try {
+        const fileConfig = JSON.parse(readFileSync(configPath, 'utf8'));
+        this.logger.info('Loaded configuration from config.json');
+        return this.mergeConfigs(baseConfig, fileConfig);
+      } catch (error) {
+        this.logger.warn('Failed to load config.json, using environment variables');
+      }
+    }
+
+    return baseConfig;
+  }
+
+  /**
+   * Merge base configuration with file configuration
+   */
+  private mergeConfigs(base: MCPConfig, override: Partial<MCPConfig>): MCPConfig {
+    return {
+      servicenow: { ...base.servicenow, ...override.servicenow },
+      neo4j: { ...base.neo4j, ...override.neo4j },
+      memory: { ...base.memory, ...override.memory },
+      performance: { ...base.performance, ...override.performance },
+      logging: { ...base.logging, ...override.logging }
+    };
+  }
+
+  /**
+   * Get the complete configuration
+   */
+  public getConfig(): MCPConfig {
+    return this.config;
+  }
+
+  /**
+   * Get ServiceNow configuration
+   */
+  public getServiceNowConfig() {
+    return this.config.servicenow;
+  }
+
+  /**
+   * Get Neo4j configuration
+   */
+  public getNeo4jConfig() {
+    return this.config.neo4j;
+  }
+
+  /**
+   * Get memory configuration
+   */
+  public getMemoryConfig() {
+    return this.config.memory;
+  }
+
+  /**
+   * Get performance configuration
+   */
+  public getPerformanceConfig() {
+    return this.config.performance;
+  }
+
+  /**
+   * Get logging configuration
+   */
+  public getLoggingConfig() {
+    return this.config.logging;
+  }
+
+  /**
+   * Validate configuration
+   */
+  public validateConfig(): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    // Validate ServiceNow configuration
+    if (!this.config.servicenow.instanceUrl) {
+      errors.push('ServiceNow instance URL is required (SERVICENOW_INSTANCE_URL)');
+    }
+    if (!this.config.servicenow.clientId) {
+      errors.push('ServiceNow client ID is required (SERVICENOW_CLIENT_ID)');
+    }
+    if (!this.config.servicenow.clientSecret) {
+      errors.push('ServiceNow client secret is required (SERVICENOW_CLIENT_SECRET)');
+    }
+
+    // Validate Neo4j configuration if enabled
+    if (this.config.memory.provider === 'neo4j') {
+      if (!this.config.neo4j?.uri) {
+        errors.push('Neo4j URI is required when using Neo4j memory provider (NEO4J_URI)');
+      }
+      if (!this.config.neo4j?.username) {
+        errors.push('Neo4j username is required when using Neo4j memory provider (NEO4J_USERNAME)');
+      }
+      if (!this.config.neo4j?.password) {
+        errors.push('Neo4j password is required when using Neo4j memory provider (NEO4J_PASSWORD)');
+      }
+    }
+
+    // Validate memory configuration
+    if (!['file', 'neo4j', 'redis'].includes(this.config.memory.provider)) {
+      errors.push('Memory provider must be one of: file, neo4j, redis');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Hot reload configuration
+   */
+  public async reloadConfig(): Promise<void> {
+    this.logger.info('Reloading configuration...');
+    this.config = this.loadConfiguration();
+    
+    const validation = this.validateConfig();
+    if (!validation.valid) {
+      this.logger.error('Configuration validation failed:', validation.errors);
+      throw new Error(`Configuration validation failed: ${validation.errors.join(', ')}`);
+    }
+    
+    this.logger.info('Configuration reloaded successfully');
+  }
+
+  /**
+   * Get environment-specific configuration
+   */
+  public getEnvironmentConfig(): { environment: string; config: MCPConfig } {
+    const environment = process.env.NODE_ENV || 'development';
+    
+    // Environment-specific overrides
+    const envOverrides: Partial<MCPConfig> = {};
+    
+    if (environment === 'production') {
+      envOverrides.logging = {
+        ...this.config.logging,
+        level: 'warn',
+        enableFileLogging: true
+      };
+      envOverrides.performance = {
+        ...this.config.performance,
+        cacheEnabled: true,
+        connectionPoolSize: 20
+      };
+    } else if (environment === 'development') {
+      envOverrides.logging = {
+        ...this.config.logging,
+        level: 'debug'
+      };
+    }
+
+    return {
+      environment,
+      config: this.mergeConfigs(this.config, envOverrides)
+    };
+  }
+}
+
+// Export singleton instance
+export const mcpConfig = MCPConfigManager.getInstance();