@elliotding/ai-agent-mcp 0.1.25 → 0.1.26

package/src/cache/redis-client.ts

@@ -1,249 +0,0 @@
-/**
- * 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

@@ -1,33 +0,0 @@
-/**
- * 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

@@ -1,269 +0,0 @@
-/**
- * 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;
-    /** URL path prefix when the server runs behind a reverse proxy sub-path.
-     *  e.g.  HTTP_BASE_PATH=/csp-agent  → SSE at /csp-agent/sse
-     *                                    → messages POST to /csp-agent/message
-     *  Leave empty (default) for direct / root-path deployments.
-     */
-    basePath: string;
-    /**
-     * The public-facing origin clients (Cursor) should use when posting
-     * JSON-RPC messages.  Derived from CSP_API_BASE_URL so that teams only
-     * need one URL configured — the API base and the MCP server share the
-     * same external hostname.
-     *
-     * e.g. CSP_API_BASE_URL=https://zct.zoomdev.us  →  publicOrigin=https://zct.zoomdev.us
-     *
-     * Falls back to PUBLIC_URL env var if set, then to the internal
-     * http://host:port when running locally (where 0.0.0.0 == localhost).
-     */
-    publicOrigin: string;
-  };
-
-  // Session (for SSE transport)
-  session?: {
-    timeout: number; // seconds
-  };
-
-  // CSP API
-  csp: {
-    apiBaseUrl: string;
-    // NOTE: No apiToken here. The user token is established during the first MCP
-    // connection (SSE Authorization header), validated, then cached per-session.
-    // Each tool call receives it via the injected user_token argument.
-    // Storing a static token in config would break multi-user scenarios.
-    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';
-
-  return {
-    nodeEnv,
-    port: getEnvNumber('PORT', 5090),
-    logLevel,
-
-    transport: {
-      mode: transportMode,
-    },
-
-    http: transportMode === 'sse' ? (() => {
-      const host     = getEnv('HTTP_HOST', '0.0.0.0');
-      const port     = getEnvNumber('HTTP_PORT', 3000);
-      const basePath = getEnv('HTTP_BASE_PATH', '');
-
-      // Derive the public-facing origin that external clients (Cursor) will use
-      // to POST JSON-RPC messages.  Priority:
-      //   1. PUBLIC_URL env var — explicit override (e.g. ngrok / custom domain)
-      //   2. Origin extracted from CSP_API_BASE_URL — same host as the API
-      //   3. http://host:port — safe for local dev where host==0.0.0.0==localhost
-      const publicUrl = process.env['PUBLIC_URL'];
-      const cspApiBase = process.env['CSP_API_BASE_URL'] ?? '';
-      let publicOrigin: string;
-      if (publicUrl) {
-        publicOrigin = publicUrl.replace(/\/$/, '');
-      } else if (cspApiBase) {
-        try {
-          const u = new URL(cspApiBase);
-          publicOrigin = u.origin; // e.g. "https://zct.zoomdev.us"
-        } catch {
-          publicOrigin = `http://${host}:${port}`;
-        }
-      } else {
-        publicOrigin = `http://${host}:${port}`;
-      }
-
-      return { host, port, basePath, publicOrigin };
-    })() : undefined,
-
-    session: transportMode === 'sse' ? {
-      timeout: getEnvNumber('SESSION_TIMEOUT', 3600),
-    } : undefined,
-
-    csp: {
-      apiBaseUrl: getEnv('CSP_API_BASE_URL', 'https://csp.example.com'),
-      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 };