@elliotding/ai-agent-mcp 0.1.25 → 0.1.26

package/src/git/operations.ts

@@ -1,93 +0,0 @@
-/**
- * Git Operations Module
- * Per-repo git helpers used by upload_resource to target a specific source repo.
- * All repo URLs and branches come from AI-Resources/ai-resources-config.json —
- * not from environment variables.
- */
-
-import simpleGit from 'simple-git';
-import { config } from '../config';
-import { logger } from '../utils/logger';
-import { createGitError } from '../types/errors';
-
-class GitOperations {
-  // ---- Per-repo helpers (used by upload_resource to target a specific source) ----
-
-  /**
-   * Check whether a git repository exists at an arbitrary local path
-   */
-  async repositoryExistsAt(repoPath: string): Promise<boolean> {
-    try {
-      const git = simpleGit({ baseDir: repoPath, binary: 'git', maxConcurrentProcesses: 6 });
-      await git.status();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get current branch of an arbitrary local repo
-   */
-  async getCurrentBranchAt(repoPath: string): Promise<string> {
-    try {
-      const git = simpleGit({ baseDir: repoPath, binary: 'git', maxConcurrentProcesses: 6 });
-      const branchSummary = await git.branch();
-      return branchSummary.current;
-    } catch (error) {
-      throw createGitError('get-branch', error as Error);
-    }
-  }
-
-  /**
-   * Commit and push to a specific repo / remote url / branch.
-   * Creates a unique remote testing branch and returns a PR URL.
-   */
-  async commitAndPushRepo(
-    repoPath: string,
-    remoteUrl: string,
-    baseBranch: string,
-    message: string,
-    files?: string[]
-  ): Promise<{ commitHash: string; prUrl?: string }> {
-    try {
-      const git = simpleGit({ baseDir: repoPath, binary: 'git', maxConcurrentProcesses: 6 });
-
-      logger.info({ repoPath, remoteUrl, message, fileCount: files?.length }, 'Committing and pushing to source repo...');
-
-      await git.addConfig('user.name', config.git.userName);
-      await git.addConfig('user.email', config.git.userEmail);
-
-      const branchSummary = await git.branch();
-      const currentBranch = branchSummary.current;
-
-      const timestamp = Date.now();
-      const randomSuffix = Math.random().toString(36).substring(2, 8);
-      const remoteBranchName = `dev-${currentBranch}-testing-${timestamp}-${randomSuffix}`;
-      logger.info({ remoteBranchName }, 'Generated remote branch name for PR');
-
-      if (files && files.length > 0) {
-        await git.add(files);
-      } else {
-        await git.add('.');
-      }
-
-      const commitResult = await git.commit(message);
-      const commitHash = commitResult.commit;
-      logger.info({ commitHash }, 'Git commit created');
-
-      await git.push(remoteUrl, `${currentBranch}:${remoteBranchName}`);
-      logger.info({ remoteBranchName }, 'Git push completed');
-
-      const repoBaseUrl = remoteUrl.replace(/\.git$/, '');
-      const prUrl = `${repoBaseUrl}/compare/${baseBranch}...${remoteBranchName}`;
-      logger.info({ prUrl, commitHash }, 'PR URL generated');
-
-      return { commitHash, prUrl };
-    } catch (error) {
-      throw createGitError('commit-push', error as Error, remoteUrl);
-    }
-  }
-}
-
-export const gitOperations = new GitOperations();

package/src/index.ts

@@ -1,157 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * CSP AI Agent MCP Server - Main Entry Point
- */
-
-import { config } from './config';
-import { logger } from './utils/logger';
-import { startLogCleanupSchedule, stopLogCleanupSchedule } from './utils/log-cleaner';
-import { startServer, stopServer } from './server';
-import { stopCacheCleanup } from './auth/token-validator';
-import { sessionManager } from './session/manager';
-import { telemetry } from './telemetry/index.js';
-import { apiClient } from './api/client.js';
-
-// Global error handlers
-process.on('uncaughtException', (error: Error) => {
-  // Handle EPIPE and ECONNRESET gracefully (client disconnected)
-  if (error.message.includes('EPIPE') || error.message.includes('ECONNRESET')) {
-    logger.debug({ 
-      error: error.message, 
-      type: 'uncaught_exception_network' 
-    }, 'Client disconnected (EPIPE/ECONNRESET)');
-    return; // Don't exit for network errors
-  }
-  
-  // For other uncaught exceptions, log and exit
-  logger.error({ error, type: 'uncaught_exception' }, `Uncaught Exception: ${error.message}`);
-  process.exit(1);
-});
-
-process.on('unhandledRejection', (reason: unknown, _promise: Promise<unknown>) => {
-  logger.error(
-    {
-      type: 'unhandled_rejection',
-      reason: reason instanceof Error ? reason.message : String(reason),
-      stack: reason instanceof Error ? reason.stack : undefined,
-    },
-    'Unhandled Promise Rejection'
-  );
-  process.exit(1);
-});
-
-async function main() {
-  logger.info(
-    {
-      nodeEnv: config.nodeEnv,
-      port: config.port,
-      logLevel: config.logLevel,
-    },
-    'Starting CSP AI Agent MCP Server...'
-  );
-
-  // Start log cleanup scheduler
-  const cleanupTimer = startLogCleanupSchedule();
-
-  // Wire up telemetry reporting (inject API client to avoid circular import).
-  // Tokens are sourced exclusively from authenticated SSE connections via setUserToken().
-  telemetry.configure(
-    (payload, token) => apiClient.reportTelemetry(payload, token)
-  );
-
-  try {
-    // Start MCP Server
-    await startServer();
-
-    logger.info({ port: config.port }, `✅ CSP AI Agent MCP Server started successfully`);
-
-    // Start periodic telemetry flush (every 10 seconds)
-    telemetry.startPeriodicFlush(10_000);
-    logger.info('Telemetry flush scheduler started (interval: 10s)');
-  } catch (error) {
-    logger.error({ error }, 'Failed to start server');
-    stopLogCleanupSchedule(cleanupTimer);
-    process.exit(1);
-  }
-
-  // Graceful shutdown handlers
-  let isShuttingDown = false;
-  const SHUTDOWN_TIMEOUT = Number(process.env.SHUTDOWN_TIMEOUT) || 30000; // 30 seconds default
-
-  const shutdown = async (signal: string) => {
-    // Prevent multiple shutdown attempts
-    if (isShuttingDown) {
-      logger.warn({ signal }, 'Shutdown already in progress, ignoring signal');
-      return;
-    }
-    isShuttingDown = true;
-
-    logger.info({ signal, timeout: SHUTDOWN_TIMEOUT }, `Received ${signal}, starting graceful shutdown...`);
-
-    // Set timeout for forced shutdown
-    const shutdownTimer = setTimeout(() => {
-      logger.error(
-        { timeout: SHUTDOWN_TIMEOUT },
-        `Graceful shutdown timeout (${SHUTDOWN_TIMEOUT}ms), forcing exit`
-      );
-      process.exit(1);
-    }, SHUTDOWN_TIMEOUT);
-
-    try {
-      // Phase 1: Stop accepting new requests
-      logger.info('Phase 1: Stopping new requests...');
-
-      // Phase 2: Wait for ongoing requests to complete
-      logger.info('Phase 2: Waiting for ongoing requests to complete...');
-
-      // Stop MCP Server (this will close all active sessions and connections)
-      await stopServer();
-
-      // Phase 3: Stop background tasks
-      logger.info('Phase 3: Stopping background tasks...');
-
-      // Stop log cleanup
-      stopLogCleanupSchedule(cleanupTimer);
-      
-      // Stop session cleanup
-      sessionManager.stopCleanup();
-      logger.info('Session cleanup stopped');
-      
-      // Stop token cache cleanup
-      stopCacheCleanup();
-      logger.info('Token cache cleanup stopped');
-
-      // Stop telemetry scheduler and perform final flush
-      telemetry.stopPeriodicFlush();
-      logger.info('Telemetry scheduler stopped, performing final flush...');
-      await telemetry.flush();
-      logger.info('Final telemetry flush completed');
-
-      // Phase 4: Flush logs
-      logger.info('Phase 4: Flushing logs...');
-      
-      // Give logger time to flush
-      await new Promise(resolve => setTimeout(resolve, 500));
-
-      // Clear shutdown timeout
-      clearTimeout(shutdownTimer);
-
-      logger.info('✅ Graceful shutdown completed successfully');
-      process.exit(0);
-    } catch (error) {
-      logger.error({ error }, 'Error during graceful shutdown');
-      clearTimeout(shutdownTimer);
-      process.exit(1);
-    }
-  };
-
-  process.on('SIGINT', () => void shutdown('SIGINT'));
-  process.on('SIGTERM', () => void shutdown('SIGTERM'));
-}
-
-// Start the application
-void main().catch((error: unknown) => {
-  logger.error({ error }, 'Fatal error during startup');
-  process.exit(1);
-});

package/src/monitoring/health.ts

@@ -1,132 +0,0 @@
-import { CacheManager } from '../cache/cache-manager.js';
-
-export interface HealthStatus {
-  status: 'healthy' | 'unhealthy';
-  timestamp: string;
-  services: {
-    http: 'up' | 'down';
-    redis: 'up' | 'down' | 'not_configured';
-    cache: 'healthy' | 'degraded' | 'down';
-  };
-  details?: {
-    redisError?: string;
-    cacheError?: string;
-  };
-}
-
-export class HealthChecker {
-  private cacheManager: CacheManager | null = null;
-
-  constructor(cacheManager?: CacheManager) {
-    this.cacheManager = cacheManager || null;
-  }
-
-  /**
-   * Check HTTP Server health
-   */
-  private checkHttpServer(): 'up' | 'down' {
-    // HTTP server is up if this code is running
-    return 'up';
-  }
-
-  /**
-   * Check Redis connection health
-   */
-  private async checkRedis(): Promise<{ status: 'up' | 'down' | 'not_configured'; error?: string }> {
-    if (!this.cacheManager) {
-      return { status: 'not_configured' };
-    }
-
-    try {
-      // Try to check Redis connection via cache manager
-      const redisCache = (this.cacheManager as any).l2Cache;
-      
-      if (!redisCache) {
-        return { status: 'not_configured' };
-      }
-
-      // Try a simple Redis operation (check client status)
-      const client = (redisCache as any).client;
-      
-      if (!client || !client.isReady) {
-        return { status: 'down', error: 'Redis client not ready' };
-      }
-
-      // Try a ping operation
-      await client.ping();
-      return { status: 'up' };
-    } catch (error) {
-      return {
-        status: 'down',
-        error: error instanceof Error ? error.message : 'Unknown error'
-      };
-    }
-  }
-
-  /**
-   * Check Cache health
-   */
-  private checkCache(): { status: 'healthy' | 'degraded' | 'down'; error?: string } {
-    if (!this.cacheManager) {
-      return { status: 'down', error: 'Cache manager not initialized' };
-    }
-
-    try {
-      // Check if cache manager is functional
-      const stats = this.cacheManager.getStats();
-      
-      // Cache is healthy if stats are available
-      if (stats && typeof stats.hitRate === 'number') {
-        // Check if hit rate is reasonable (> 0 means cache is working)
-        if (stats.hitRate >= 0) {
-          return { status: 'healthy' };
-        }
-        return { status: 'degraded', error: 'Low cache hit rate' };
-      }
-
-      return { status: 'degraded', error: 'Cache stats unavailable' };
-    } catch (error) {
-      return {
-        status: 'down',
-        error: error instanceof Error ? error.message : 'Unknown error'
-      };
-    }
-  }
-
-  /**
-   * Perform comprehensive health check
-   */
-  async check(): Promise<HealthStatus> {
-    const httpStatus = this.checkHttpServer();
-    const redisResult = await this.checkRedis();
-    const cacheResult = this.checkCache();
-
-    const allHealthy = 
-      httpStatus === 'up' &&
-      (redisResult.status === 'up' || redisResult.status === 'not_configured') &&
-      cacheResult.status === 'healthy';
-
-    const health: HealthStatus = {
-      status: allHealthy ? 'healthy' : 'unhealthy',
-      timestamp: new Date().toISOString(),
-      services: {
-        http: httpStatus,
-        redis: redisResult.status,
-        cache: cacheResult.status
-      }
-    };
-
-    // Add error details if any
-    if (redisResult.error || cacheResult.error) {
-      health.details = {};
-      if (redisResult.error) {
-        health.details.redisError = redisResult.error;
-      }
-      if (cacheResult.error) {
-        health.details.cacheError = cacheResult.error;
-      }
-    }
-
-    return health;
-  }
-}

package/src/prompts/cache.ts

@@ -1,140 +0,0 @@
-/**
- * PromptCache: manages the .prompt-cache/ directory inside the MCP Server's
- * runtime working directory.
- *
- * Cache files hold the fully-expanded Prompt content for each Command/Skill
- * resource so that the MCP Prompt handler can serve them without re-generating
- * on every invocation.
- *
- * The cache directory is intentionally NOT committed to Git — it is regenerated
- * from the canonical source files after every git pull or resource upload.
- *
- * File naming: {type}-{resource_id}.md
- *   e.g.  cmd-client-sdk-generate-testcase.md
- *         skill-client-sdk-analyze-sdk-log.md
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { logger } from '../utils/logger.js';
-
-/** Relative directory name inside the MCP Server CWD for cached Prompt files. */
-const CACHE_DIR_NAME = '.prompt-cache';
-
-export class PromptCache {
-  private readonly cacheDir: string;
-
-  /**
-   * @param baseDir  Absolute base directory (defaults to process.cwd()).
-   */
-  constructor(baseDir: string = process.cwd()) {
-    this.cacheDir = path.join(baseDir, CACHE_DIR_NAME);
-  }
-
-  /** Absolute path to the cache directory. */
-  get directory(): string {
-    return this.cacheDir;
-  }
-
-  /** Ensure the cache directory exists (idempotent). */
-  ensureDir(): void {
-    fs.mkdirSync(this.cacheDir, { recursive: true });
-  }
-
-  /**
-   * Derive the cache file name for a resource.
-   * @param resourceType  'command' | 'skill'
-   * @param resourceId    Canonical resource ID
-   */
-  private cacheFileName(resourceType: string, resourceId: string): string {
-    // Normalise type prefix: 'command' → 'cmd', 'skill' → 'skill'
-    const prefix = resourceType === 'command' ? 'cmd' : resourceType;
-    // Sanitise resourceId — remove characters unsafe in filenames.
-    const safeId = resourceId.replace(/[/\\:*?"<>|]/g, '-');
-    return `${prefix}-${safeId}.md`;
-  }
-
-  /** Absolute path to the cache file for a given resource. */
-  cachePath(resourceType: string, resourceId: string): string {
-    return path.join(this.cacheDir, this.cacheFileName(resourceType, resourceId));
-  }
-
-  /**
-   * Write (or overwrite) a resource's Prompt content to the cache.
-   * Uses atomic write-then-rename to prevent partial reads.
-   *
-   * @param resourceType  'command' | 'skill'
-   * @param resourceId    Canonical resource ID
-   * @param content       Fully-expanded Prompt Markdown content
-   */
-  write(resourceType: string, resourceId: string, content: string): void {
-    this.ensureDir();
-    const dest = this.cachePath(resourceType, resourceId);
-    const tmp = `${dest}.${process.pid}.tmp`;
-    try {
-      fs.writeFileSync(tmp, content, 'utf8');
-      fs.renameSync(tmp, dest);
-      logger.debug(
-        { resourceId, resourceType, path: dest },
-        'Prompt cache written',
-      );
-    } catch (err) {
-      // Best-effort cleanup of temp file
-      try { fs.unlinkSync(tmp); } catch { /* ignore */ }
-      throw new Error(
-        `Failed to write prompt cache for ${resourceId}: ${(err as Error).message}`,
-      );
-    }
-  }
-
-  /**
-   * Read the cached Prompt content for a resource.
-   * Returns null if the cache file does not exist or cannot be read.
-   *
-   * @param resourceType  'command' | 'skill'
-   * @param resourceId    Canonical resource ID
-   */
-  read(resourceType: string, resourceId: string): string | null {
-    const p = this.cachePath(resourceType, resourceId);
-    try {
-      return fs.readFileSync(p, 'utf8');
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Delete the cache file for a resource.
-   * Silently succeeds if the file does not exist.
-   *
-   * @param resourceType  'command' | 'skill'
-   * @param resourceId    Canonical resource ID
-   */
-  delete(resourceType: string, resourceId: string): void {
-    const p = this.cachePath(resourceType, resourceId);
-    try {
-      fs.unlinkSync(p);
-      logger.debug({ resourceId, resourceType }, 'Prompt cache deleted');
-    } catch (err: unknown) {
-      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
-        logger.warn(
-          { resourceId, error: (err as Error).message },
-          'Failed to delete prompt cache file',
-        );
-      }
-    }
-  }
-
-  /**
-   * Check whether a valid cache entry exists for a resource.
-   *
-   * @param resourceType  'command' | 'skill'
-   * @param resourceId    Canonical resource ID
-   */
-  exists(resourceType: string, resourceId: string): boolean {
-    return fs.existsSync(this.cachePath(resourceType, resourceId));
-  }
-}
-
-/** Singleton cache instance using the process CWD as the base directory. */
-export const promptCache = new PromptCache();

package/src/prompts/generator.ts

@@ -1,143 +0,0 @@
-/**
- * PromptGenerator: converts raw Command/Skill Markdown assets into MCP Prompt content.
- *
- * Two-step pipeline:
- *  1. parseMarkdownWithImports — recursively inline `import 'path'` directives.
- *  2. replaceMDVariables       — substitute ${VAR} placeholders with runtime values.
- *
- * The resulting string is returned to the caller who can pass it directly as
- * the MCP Prompt message text, or write it to the .prompt-cache/ directory.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { logger } from '../utils/logger.js';
-
-// Maximum import recursion depth to guard against circular imports.
-const MAX_IMPORT_DEPTH = 20;
-
-// Matches lines like:  import 'relative/path/to/file.md'
-const IMPORT_REGEX = /^import\s+['"]([^'"]+)['"]\s*$/gm;
-
-/**
- * Recursively resolve and inline all `import 'path'` statements in a Markdown
- * file.  Each imported file's content replaces its import statement in the
- * parent document.
- *
- * @param filePath  Absolute path to the root Markdown file.
- * @param depth     Current recursion depth (used for cycle detection).
- * @returns         Fully expanded Markdown string.
- */
-export async function parseMarkdownWithImports(
-  filePath: string,
-  depth = 0,
-): Promise<string> {
-  if (depth > MAX_IMPORT_DEPTH) {
-    throw new Error(
-      `Import depth exceeded ${MAX_IMPORT_DEPTH} levels at ${filePath}. ` +
-      'Check for circular imports.',
-    );
-  }
-
-  let content: string;
-  try {
-    content = fs.readFileSync(filePath, 'utf8');
-  } catch (err) {
-    throw new Error(`Cannot read Markdown file: ${filePath} — ${(err as Error).message}`);
-  }
-
-  const fileDir = path.dirname(filePath);
-  const matches: Array<{ statement: string; resolvedPath: string }> = [];
-
-  let match: RegExpExecArray | null;
-  // Reset lastIndex before each exec loop (regex is stateful with 'g' flag).
-  IMPORT_REGEX.lastIndex = 0;
-  while ((match = IMPORT_REGEX.exec(content)) !== null) {
-    const importPath = match[1];
-    if (importPath) {
-      matches.push({
-        statement: match[0],
-        resolvedPath: path.resolve(fileDir, importPath),
-      });
-    }
-  }
-
-  // Process imports sequentially to preserve insertion order.
-  for (const { statement, resolvedPath } of matches) {
-    try {
-      const importedContent = await parseMarkdownWithImports(resolvedPath, depth + 1);
-      content = content.replace(statement, importedContent);
-    } catch (err) {
-      logger.warn(
-        { importPath: resolvedPath, parentFile: filePath, error: (err as Error).message },
-        'Failed to resolve import — leaving placeholder in place',
-      );
-    }
-  }
-
-  return content;
-}
-
-/**
- * Replace ${VARIABLE_NAME} placeholders in content with values from the
- * provided variable map.  Variables not found in the map are left unchanged so
- * they remain visible in the output for debugging.
- *
- * @param content   Markdown string (after import expansion).
- * @param variables Key-value map of variable names to their replacement strings.
- * @returns         Content with placeholders substituted.
- */
-export function replaceMDVariables(
-  content: string,
-  variables: Record<string, string>,
-): string {
-  let result = content;
-  for (const [key, value] of Object.entries(variables)) {
-    const regex = new RegExp(`\\$\\{${key}\\}`, 'g');
-    result = result.replace(regex, value);
-  }
-  return result;
-}
-
-/**
- * High-level entry point: expand imports then substitute variables.
- *
- * @param filePath  Absolute path to the root Markdown file.
- * @param variables Optional variable substitution map (defaults to empty).
- * @returns         Final Prompt content ready for MCP registration.
- */
-export async function generatePromptContent(
-  filePath: string,
-  variables: Record<string, string> = {},
-): Promise<string> {
-  const expanded = await parseMarkdownWithImports(filePath);
-  return replaceMDVariables(expanded, variables);
-}
-
-/**
- * Generate Prompt content from a raw Markdown string (no file I/O).
- * Used when the resource content has already been downloaded from the API.
- *
- * @param rawContent Raw Markdown string.
- * @param basePath   Absolute directory used to resolve relative `import` paths.
- * @param variables  Optional variable substitution map.
- * @returns          Final Prompt content.
- */
-export async function generatePromptContentFromString(
-  rawContent: string | undefined | null,
-  basePath: string,
-  variables: Record<string, string> = {},
-): Promise<string> {
-  if (!rawContent) return '';
-  // Write to a temp file so parseMarkdownWithImports can resolve relative imports.
-  const tmpPath = path.join(basePath, `.tmp-prompt-${Date.now()}-${process.pid}.md`);
-  let result: string;
-  try {
-    fs.mkdirSync(basePath, { recursive: true });
-    fs.writeFileSync(tmpPath, rawContent, 'utf8');
-    result = await parseMarkdownWithImports(tmpPath);
-  } finally {
-    try { fs.unlinkSync(tmpPath); } catch { /* best-effort cleanup */ }
-  }
-  return replaceMDVariables(result, variables);
-}

package/src/prompts/index.ts

@@ -1,20 +0,0 @@
-/**
- * prompts module — public API
- *
- * Exports:
- *  - PromptGenerator utilities (parseMarkdownWithImports, replaceMDVariables,
- *    generatePromptContent, generatePromptContentFromString)
- *  - PromptCache class and the shared singleton `promptCache`
- *  - PromptManager class and the shared singleton `promptManager`
- */
-
-export {
-  parseMarkdownWithImports,
-  replaceMDVariables,
-  generatePromptContent,
-  generatePromptContentFromString,
-} from './generator.js';
-
-export { PromptCache, promptCache } from './cache.js';
-
-export { PromptManager, promptManager } from './manager.js';