@elliotding/ai-agent-mcp 0.1.0

package/src/cache/redis-client.ts

@@ -0,0 +1,249 @@
+/**
+ * Redis Client Module
+ * Connection management with retry strategy and basic cache operations
+ */
+
+import Redis, { type Redis as RedisInstance } from 'ioredis';
+import { logger, logError } from '../utils/logger';
+import { config } from '../config';
+
+const RETRY_BASE_MS = 100;
+const RETRY_MAX_MS = 5000;
+const RETRY_MAX_ATTEMPTS = 10;
+
+/**
+ * Exponential backoff: base * 2^times, capped at max
+ */
+function exponentialBackoff(times: number): number {
+  if (times > RETRY_MAX_ATTEMPTS) {
+    return 0; // Stop retrying
+  }
+  const delay = Math.min(RETRY_BASE_MS * Math.pow(2, times), RETRY_MAX_MS);
+  return delay;
+}
+
+export class RedisClient {
+  private static instance: RedisClient | null = null;
+  private client: RedisInstance | null = null;
+  private isConnecting = false;
+
+  private constructor() {}
+
+  static getInstance(): RedisClient {
+    if (RedisClient.instance === null) {
+      RedisClient.instance = new RedisClient();
+    }
+    return RedisClient.instance;
+  }
+
+  /**
+   * Connect to Redis with config and retry strategy
+   */
+  async connect(): Promise<void> {
+    const redisConfig = config.cache?.redis;
+    if (!redisConfig?.url) {
+      logger.warn(
+        { type: 'redis', event: 'connect_skipped' },
+        'Redis URL not configured (REDIS_URL), skipping connection'
+      );
+      return;
+    }
+
+    if (this.client && this.isConnected()) {
+      logger.debug({ type: 'redis', event: 'connect' }, 'Redis already connected');
+      return;
+    }
+
+    if (this.isConnecting) {
+      logger.debug({ type: 'redis', event: 'connect' }, 'Redis connection in progress');
+      return;
+    }
+
+    this.isConnecting = true;
+
+    try {
+      this.client = new Redis(redisConfig.url, {
+        retryStrategy: (times: number) => {
+          const delay = exponentialBackoff(times);
+          if (delay === 0) {
+            logger.error(
+              { type: 'redis', event: 'retry_exhausted', times },
+              'Redis retry exhausted, giving up'
+            );
+            return undefined;
+          }
+          logger.warn(
+            { type: 'redis', event: 'retry', times, delayMs: delay },
+            `Redis reconnecting in ${delay}ms (attempt ${times})`
+          );
+          return delay;
+        },
+        maxRetriesPerRequest: null,
+        connectTimeout: 10000,
+        lazyConnect: true,
+      });
+
+      this.client.on('connect', () => {
+        logger.info(
+          { type: 'redis', event: 'connect' },
+          'Redis connection established'
+        );
+      });
+
+      this.client.on('ready', () => {
+        this.isConnecting = false;
+        logger.info(
+          { type: 'redis', event: 'ready' },
+          'Redis client ready'
+        );
+      });
+
+      this.client.on('error', (err: Error) => {
+        logger.error(
+          { type: 'redis', event: 'error', error: err.message },
+          `Redis error: ${err.message}`
+        );
+      });
+
+      this.client.on('close', () => {
+        logger.info(
+          { type: 'redis', event: 'close' },
+          'Redis connection closed'
+        );
+      });
+
+      await this.client.connect();
+    } catch (error) {
+      this.isConnecting = false;
+      if (this.client) {
+        this.client.disconnect();
+        this.client = null;
+      }
+      logError(error as Error, { type: 'redis', event: 'connect_failed' });
+      throw error;
+    }
+  }
+
+  /**
+   * Gracefully disconnect from Redis
+   */
+  async disconnect(): Promise<void> {
+    if (!this.client) {
+      logger.debug({ type: 'redis', event: 'disconnect' }, 'Redis not connected');
+      return;
+    }
+
+    try {
+      await this.client.quit();
+      this.client = null;
+      logger.info(
+        { type: 'redis', event: 'disconnect' },
+        'Redis disconnected gracefully'
+      );
+    } catch (error) {
+      logError(error as Error, { type: 'redis', event: 'disconnect_failed' });
+      this.client = null;
+      throw error;
+    }
+  }
+
+  /**
+   * Check if Redis client is connected
+   */
+  isConnected(): boolean {
+    return this.client?.status === 'ready';
+  }
+
+  /**
+   * Get value by key
+   */
+  async get(key: string): Promise<string | null> {
+    if (!this.client) {
+      logger.warn({ type: 'redis', operation: 'get', key }, 'Redis not connected');
+      return null;
+    }
+
+    try {
+      const value = await this.client.get(key);
+      return value;
+    } catch (error) {
+      logError(error as Error, { type: 'redis', operation: 'get', key });
+      throw error;
+    }
+  }
+
+  /**
+   * Set value with optional TTL (seconds)
+   */
+  async set(key: string, value: string, ttl?: number): Promise<void> {
+    if (!this.client) {
+      logger.warn({ type: 'redis', operation: 'set', key }, 'Redis not connected');
+      throw new Error('Redis not connected');
+    }
+
+    try {
+      const ttlSeconds = ttl ?? config.cache?.redis?.ttl ?? 900;
+      await this.client.set(key, value, 'EX', ttlSeconds);
+    } catch (error) {
+      logError(error as Error, { type: 'redis', operation: 'set', key });
+      throw error;
+    }
+  }
+
+  /**
+   * Delete key
+   */
+  async del(key: string): Promise<void> {
+    if (!this.client) {
+      logger.warn({ type: 'redis', operation: 'del', key }, 'Redis not connected');
+      throw new Error('Redis not connected');
+    }
+
+    try {
+      await this.client.del(key);
+    } catch (error) {
+      logError(error as Error, { type: 'redis', operation: 'del', key });
+      throw error;
+    }
+  }
+
+  /**
+   * Clear all keys matching a pattern. Use with caution.
+   */
+  async clear(pattern = '*'): Promise<void> {
+    if (!this.client) {
+      logger.warn({ type: 'redis', operation: 'clear', pattern }, 'Redis not connected');
+      throw new Error('Redis not connected');
+    }
+
+    try {
+      const keys = await this.client.keys(pattern);
+      if (keys.length > 0) {
+        await this.client.del(...keys);
+      }
+    } catch (error) {
+      logError(error as Error, { type: 'redis', operation: 'clear', pattern });
+      throw error;
+    }
+  }
+
+  /**
+   * Check if key exists
+   */
+  async exists(key: string): Promise<boolean> {
+    if (!this.client) {
+      logger.warn({ type: 'redis', operation: 'exists', key }, 'Redis not connected');
+      return false;
+    }
+
+    try {
+      const result = await this.client.exists(key);
+      return result === 1;
+    } catch (error) {
+      logError(error as Error, { type: 'redis', operation: 'exists', key });
+      throw error;
+    }
+  }
+}
+
+export const redisClient = RedisClient.getInstance();

package/src/config/constants.ts

@@ -0,0 +1,33 @@
+/**
+ * Configuration Constants
+ */
+
+export const APP_NAME = 'csp-ai-agent-mcp';
+export const APP_VERSION = '0.1.0';
+
+export const DEFAULT_PORT = 5090;
+export const DEFAULT_LOG_LEVEL = 'info';
+export const DEFAULT_API_TIMEOUT = 30000;
+
+export const LOG_RETENTION_DAYS = 3;
+export const LOG_DIR = 'logs';
+export const LOG_FILE_PATTERN = 'app-{date}.log';
+
+export const CACHE_TTL_SECONDS = 900; // 15 minutes
+export const MEMORY_CACHE_SIZE = 20;
+
+export const TOOL_NAMES = {
+  SYNC_RESOURCES: 'sync_resources',
+  MANAGE_SUBSCRIPTION: 'manage_subscription',
+  SEARCH_RESOURCES: 'search_resources',
+  UPLOAD_RESOURCE: 'upload_resource',
+  UNINSTALL_RESOURCE: 'uninstall_resource',
+} as const;
+
+export const TOOL_TIMEOUTS = {
+  [TOOL_NAMES.SEARCH_RESOURCES]: 10000, // 10s
+  [TOOL_NAMES.SYNC_RESOURCES]: 60000, // 60s
+  [TOOL_NAMES.UPLOAD_RESOURCE]: 120000, // 120s
+  [TOOL_NAMES.MANAGE_SUBSCRIPTION]: 15000, // 15s
+  [TOOL_NAMES.UNINSTALL_RESOURCE]: 5000, // 5s
+} as const;

package/src/config/index.ts

@@ -0,0 +1,228 @@
+/**
+ * Configuration Management Module
+ * Loads and validates configuration from environment variables
+ */
+
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+import * as fs from 'fs';
+
+// Load .env file if exists
+// Try multiple paths to find .env file
+const possibleEnvPaths = [
+  path.resolve(process.cwd(), '.env'),                    // Current working directory
+  path.resolve(__dirname, '../../.env'),                  // Relative to compiled dist/config/
+  path.resolve(__dirname, '../../../.env'),               // Project root (if deeper nesting)
+];
+
+let envLoaded = false;
+for (const envPath of possibleEnvPaths) {
+  if (fs.existsSync(envPath)) {
+    dotenv.config({ path: envPath });
+    console.log(`✓ Loaded .env from: ${envPath}`);
+    envLoaded = true;
+    break;
+  }
+}
+
+if (!envLoaded) {
+  console.warn('⚠ No .env file found, using environment variables only');
+}
+
+export interface Config {
+  // Environment
+  nodeEnv: 'development' | 'production' | 'test';
+
+  // Server
+  port: number;
+  logLevel: 'debug' | 'info' | 'warn' | 'error';
+
+  // Transport
+  transport: {
+    mode: 'stdio' | 'sse';
+  };
+
+  // HTTP Server (for SSE transport)
+  http?: {
+    host: string;
+    port: number;
+  };
+
+  // Session (for SSE transport)
+  session?: {
+    timeout: number; // seconds
+  };
+
+  // CSP API
+  csp: {
+    apiBaseUrl: string;
+    apiToken: string;
+    timeout: number;
+  };
+
+  // Git — only commit author info; repo URLs/branches live in ai-resources-config.json
+  git: {
+    userName: string;
+    userEmail: string;
+  };
+
+  // Resource Storage — resolved at runtime via cursor-paths utility.
+  // No longer stored in config; use getCursorTypeDir() / getCursorResourcePath() directly.
+  // Kept as an empty marker so consumers know where to look.
+  resource: Record<string, never>;
+
+  // Cache (optional)
+  cache: {
+    enabled: boolean;
+    redis?: {
+      url: string;
+      ttl: number;
+    };
+    memory: {
+      maxSize: number;
+    };
+  };
+
+  // Database (optional)
+  database?: {
+    url: string;
+  };
+
+  // Monitoring (optional)
+  metrics: {
+    enabled: boolean;
+    port?: number;
+  };
+
+  // Logging
+  logging: {
+    dir: string;
+    retentionDays: number;
+  };
+}
+
+function getEnv(key: string, defaultValue?: string): string {
+  const value = process.env[key];
+  if (value === undefined) {
+    if (defaultValue !== undefined) {
+      return defaultValue;
+    }
+    throw new Error(`Missing required environment variable: ${key}`);
+  }
+  return value;
+}
+
+function getEnvNumber(key: string, defaultValue?: number): number {
+  const value = process.env[key];
+  if (value === undefined) {
+    if (defaultValue !== undefined) {
+      return defaultValue;
+    }
+    throw new Error(`Missing required environment variable: ${key}`);
+  }
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    throw new Error(`Environment variable ${key} must be a number, got: ${value}`);
+  }
+  return parsed;
+}
+
+function getEnvBoolean(key: string, defaultValue: boolean): boolean {
+  const value = process.env[key];
+  if (value === undefined) {
+    return defaultValue;
+  }
+  return value.toLowerCase() === 'true';
+}
+
+export function loadConfig(): Config {
+  const nodeEnv = (process.env.NODE_ENV || 'development') as Config['nodeEnv'];
+  const logLevel = (process.env.LOG_LEVEL || 'info') as Config['logLevel'];
+  const transportMode = (process.env.TRANSPORT_MODE || 'stdio') as 'stdio' | 'sse';
+
+  // Debug: Log CSP_API_TOKEN to verify it was loaded
+  console.log(`🔑 CSP_API_TOKEN from env: ${process.env.CSP_API_TOKEN ? process.env.CSP_API_TOKEN.substring(0, 20) + '...' : 'NOT SET'}`);
+
+  return {
+    nodeEnv,
+    port: getEnvNumber('PORT', 5090),
+    logLevel,
+
+    transport: {
+      mode: transportMode,
+    },
+
+    http: transportMode === 'sse' ? {
+      host: getEnv('HTTP_HOST', '0.0.0.0'),
+      port: getEnvNumber('HTTP_PORT', 3000),
+    } : undefined,
+
+    session: transportMode === 'sse' ? {
+      timeout: getEnvNumber('SESSION_TIMEOUT', 3600),
+    } : undefined,
+
+    csp: {
+      apiBaseUrl: getEnv('CSP_API_BASE_URL', 'https://csp.example.com'),
+      apiToken: getEnv('CSP_API_TOKEN', 'test-token-12345'),
+      timeout: getEnvNumber('CSP_API_TIMEOUT', 30000),
+    },
+
+    git: {
+      userName: getEnv('GIT_USER_NAME', 'CSP Agent'),
+      userEmail: getEnv('GIT_USER_EMAIL', 'agent@example.com'),
+    },
+
+    resource: {},
+
+    cache: {
+      enabled: getEnvBoolean('ENABLE_CACHE', true),
+      redis: process.env.REDIS_URL
+        ? {
+            url: process.env.REDIS_URL,
+            ttl: getEnvNumber('REDIS_TTL', 900),
+          }
+        : undefined,
+      memory: {
+        maxSize: getEnvNumber('CACHE_MAX_SIZE', 100),
+      },
+    },
+
+    database: process.env.DATABASE_URL
+      ? {
+          url: process.env.DATABASE_URL,
+        }
+      : undefined,
+
+    metrics: {
+      enabled: getEnvBoolean('ENABLE_METRICS', true),
+      port: process.env.METRICS_PORT ? getEnvNumber('METRICS_PORT') : undefined,
+    },
+
+    logging: {
+      dir: getEnv('LOG_DIR', '../Logs'),
+      retentionDays: getEnvNumber('LOG_RETENTION_DAYS', 3),
+    },
+  };
+}
+
+// Validate configuration on load
+let config: Config;
+
+try {
+  config = loadConfig();
+} catch (error) {
+  // Use logger for consistent error reporting
+  const logger = require('../utils/logger').logger;
+  logger.error(
+    { 
+      type: 'config', 
+      operation: 'load_config', 
+      error: (error as Error).message,
+      stack: (error as Error).stack
+    },
+    'Configuration loading failed'
+  );
+  process.exit(1);
+}
+
+export { config };