@elliotding/ai-agent-mcp 0.1.25 → 0.1.26

package/src/server.ts

@@ -1,206 +0,0 @@
-/**
- * MCP Server Main Logic
- * Implements Model Context Protocol server with dual transport support
- */
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import { logger } from './utils/logger';
-import { config } from './config';
-import { toolRegistry } from './tools/registry';
-import {
-  syncResourcesTool,
-  manageSubscriptionTool,
-  searchResourcesTool,
-  uploadResourceTool,
-  uninstallResourceTool,
-  trackUsageTool,
-  resolvePromptContentTool,
-} from './tools';
-import { httpServer } from './server/http';
-
-let server: Server | null = null;
-
-/**
- * Register all MCP tools
- */
-function registerTools() {
-  logger.info('Registering MCP tools...');
-
-  toolRegistry.registerTool(syncResourcesTool);
-  toolRegistry.registerTool(manageSubscriptionTool);
-  toolRegistry.registerTool(searchResourcesTool);
-  toolRegistry.registerTool(uploadResourceTool);
-  toolRegistry.registerTool(uninstallResourceTool);
-  toolRegistry.registerTool(trackUsageTool);
-  toolRegistry.registerTool(resolvePromptContentTool);
-
-  logger.info(
-    { toolCount: toolRegistry.getToolCount() },
-    `Registered ${toolRegistry.getToolCount()} MCP tools`
-  );
-}
-
-/**
- * Start MCP Server with stdio transport
- */
-async function startStdioServer(): Promise<void> {
-  logger.info('Starting MCP Server with stdio transport...');
-
-  // Create MCP Server
-  server = new Server(
-    {
-      name: 'csp-ai-agent-mcp',
-      version: '0.2.0',
-    },
-    {
-      capabilities: {
-        tools: {},
-        prompts: {},
-      },
-    }
-  );
-
-  // Install Prompt list/get handlers so Command and Skill resources are
-  // exposed as MCP Prompts (Cursor slash commands).
-  const { promptManager } = await import('./prompts/index.js');
-  promptManager.installHandlers(server);
-
-  // Handle tools/list request
-  server.setRequestHandler(ListToolsRequestSchema, () => {
-    const tools = toolRegistry.getMCPToolDefinitions();
-    logger.debug({ toolCount: tools.length }, 'tools/list request handled');
-    return {
-      tools,
-    };
-  });
-
-  // Handle tools/call request
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-
-    logger.info({ toolName: name, arguments: args }, `tools/call request: ${name}`);
-
-    const tool = toolRegistry.getTool(name);
-    if (!tool) {
-      const error = `Tool not found: ${name}`;
-      logger.error({ toolName: name }, error);
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: JSON.stringify({
-              success: false,
-              error: {
-                code: 'TOOL_NOT_FOUND',
-                message: error,
-              },
-            }),
-          },
-        ],
-        isError: true,
-      };
-    }
-
-    try {
-      // Call the tool handler
-      const result = await tool.handler(args || {});
-
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: JSON.stringify(result),
-          },
-        ],
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error({ toolName: name, error: errorMessage }, `Tool execution failed: ${name}`);
-
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: JSON.stringify({
-              success: false,
-              error: {
-                code: 'TOOL_EXECUTION_ERROR',
-                message: errorMessage,
-              },
-            }),
-          },
-        ],
-        isError: true,
-      };
-    }
-  });
-
-  // Connect to stdio transport
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-
-  // Flush any pending telemetry immediately — stdio reconnects when Cursor
-  // restarts the process, so treat connect as a reconnect event.
-  const { telemetry: tel } = await import('./telemetry/index.js');
-  tel.flushOnReconnect();
-
-  logger.info('✅ MCP Server started successfully (stdio transport)');
-}
-
-/**
- * Start MCP Server with SSE transport
- */
-async function startSSEServer(): Promise<void> {
-  logger.info('Starting MCP Server with SSE transport...');
-
-  // Start HTTP server
-  await httpServer.start();
-
-  logger.info('✅ MCP Server started successfully (SSE transport)');
-}
-
-/**
- * Start MCP Server (auto-detect transport mode)
- */
-export async function startServer(): Promise<void> {
-  // Register all tools (common for both transports)
-  registerTools();
-
-  // Start server based on transport mode
-  const transportMode = config.transport.mode;
-  
-  logger.info({ transportMode }, `Starting server with ${transportMode} transport`);
-
-  if (transportMode === 'sse') {
-    await startSSEServer();
-  } else {
-    await startStdioServer();
-  }
-}
-
-/**
- * Stop MCP Server
- */
-export async function stopServer(): Promise<void> {
-  logger.info('Stopping MCP Server...');
-
-  const transportMode = config.transport.mode;
-
-  if (transportMode === 'sse') {
-    // Stop HTTP server
-    await httpServer.stop();
-  } else {
-    // Stop stdio server
-    if (server) {
-      await server.close();
-      server = null;
-    }
-  }
-
-  logger.info('MCP Server stopped');
-}

package/src/session/manager.ts

@@ -1,296 +0,0 @@
-/**
- * Session Manager
- * Manages SSE sessions and connections
- */
-
-import { randomUUID } from 'crypto';
-import type { ServerResponse } from 'http';
-import { logger } from '../utils/logger';
-import { config } from '../config';
-
-export interface Session {
-  id: string;
-  userId: string;
-  email: string;
-  groups: string[];  // Changed from 'roles' to 'groups'
-  token: string;
-  ip: string;
-  createdAt: Date;
-  lastActivity: Date;
-  connection?: ServerResponse;
-}
-
-export interface CreateSessionOptions {
-  userId?: string;
-  email?: string;
-  groups?: string[];  // Changed from 'roles' to 'groups'
-}
-
-export class SessionManager {
-  private sessions: Map<string, Session> = new Map();
-  private totalSessions: number = 0;
-  private cleanupInterval?: NodeJS.Timeout;
-
-  constructor() {
-    // Start cleanup interval
-    this.startCleanup();
-  }
-
-  /**
-   * Create new session
-   * @param token - Auth token (JWT from CSP)
-   * @param ip - Client IP address
-   * @param options - User info from /user/permissions API (userId, email, groups)
-   */
-  async createSession(
-    token: string,
-    ip: string,
-    options?: CreateSessionOptions
-  ): Promise<Session> {
-    const sessionId = randomUUID();
-
-    const userId = options?.userId ?? this.extractUserIdFromToken(token);
-    const email = options?.email ?? '';
-    const groups = options?.groups ?? [];
-
-    const session: Session = {
-      id: sessionId,
-      userId,
-      email,
-      groups,
-      token,
-      ip,
-      createdAt: new Date(),
-      lastActivity: new Date(),
-    };
-
-    this.sessions.set(sessionId, session);
-    this.totalSessions++;
-
-    logger.info({ sessionId, userId, email, groups, ip }, 'Session created');
-
-    return session;
-  }
-
-  /**
-   * Get session by ID
-   */
-  getSession(sessionId: string): Session | undefined {
-    return this.sessions.get(sessionId);
-  }
-
-  /**
-   * Register SSE connection with session
-   */
-  registerConnection(sessionId: string, connection: ServerResponse): void {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.connection = connection;
-      logger.debug({ sessionId }, 'Connection registered with session');
-    }
-  }
-
-  /**
-   * Send message to session via SSE
-   * Enhanced error handling to prevent EPIPE errors
-   * Note: This is synchronous for SSE transport compatibility
-   */
-  sendMessage(sessionId: string, message: unknown): boolean {
-    const session = this.sessions.get(sessionId);
-    if (!session || !session.connection || session.connection.destroyed) {
-      logger.debug({ sessionId }, 'Cannot send message: session not found or connection closed');
-      return false;
-    }
-
-    try {
-      const data = JSON.stringify(message);
-      
-      // Use write callback to detect errors (fire-and-forget)
-      let writeSuccess = true;
-      session.connection.write(`data: ${data}\n\n`, (err: Error | null | undefined) => {
-        if (err) {
-          // Handle specific error types
-          if (err.message.includes('EPIPE') || err.message.includes('ECONNRESET')) {
-            logger.debug({ 
-              sessionId, 
-              error: err.message 
-            }, 'Message write failed (client disconnected)');
-          } else {
-            logger.warn({ 
-              sessionId, 
-              error: err.message 
-            }, 'Message write failed');
-          }
-          writeSuccess = false;
-        } else {
-          logger.debug({ sessionId, messageSize: data.length }, 'Message sent to session');
-        }
-      });
-      
-      return writeSuccess;
-    } catch (error) {
-      // Catch synchronous errors
-      if (error instanceof Error) {
-        if (error.message.includes('EPIPE') || error.message.includes('ECONNRESET')) {
-          logger.debug({ 
-            sessionId, 
-            error: error.message 
-          }, 'Message send failed (client disconnected)');
-        } else {
-          logger.error({ 
-            error: error.message, 
-            sessionId 
-          }, 'Failed to send message to session');
-        }
-      }
-      return false;
-    }
-  }
-
-  /**
-   * Update session activity timestamp
-   */
-  updateActivity(sessionId: string): void {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.lastActivity = new Date();
-    }
-  }
-
-  /**
-   * Close session with improved error handling
-   */
-  closeSession(sessionId: string): void {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      // Close connection if exists
-      if (session.connection && !session.connection.destroyed) {
-        try {
-          // Try to send close message
-          session.connection.write(`data: ${JSON.stringify({ type: 'close' })}\n\n`, (err) => {
-            if (err) {
-              logger.debug({ 
-                sessionId, 
-                error: err.message 
-              }, 'Close message write failed (expected if client already disconnected)');
-            }
-          });
-          
-          // End connection
-          session.connection.end();
-        } catch (error) {
-          if (error instanceof Error) {
-            // Only log non-EPIPE errors as warnings
-            if (error.message.includes('EPIPE') || error.message.includes('ECONNRESET')) {
-              logger.debug({ 
-                sessionId, 
-                error: error.message 
-              }, 'Connection already closed');
-            } else {
-              logger.warn({ 
-                sessionId, 
-                error: error.message 
-              }, 'Error closing connection');
-            }
-          }
-        }
-      }
-
-      // Remove session
-      this.sessions.delete(sessionId);
-      logger.info({ sessionId }, 'Session closed');
-    }
-  }
-
-  /**
-   * Close all sessions
-   */
-  closeAllSessions(): void {
-    logger.info({ count: this.sessions.size }, 'Closing all sessions');
-    
-    for (const [sessionId] of this.sessions) {
-      this.closeSession(sessionId);
-    }
-  }
-
-  /**
-   * Get active session count
-   */
-  getActiveSessionCount(): number {
-    return this.sessions.size;
-  }
-
-  /**
-   * Get total session count (since server start)
-   */
-  getTotalSessionCount(): number {
-    return this.totalSessions;
-  }
-
-  /**
-   * Get all active sessions
-   */
-  getActiveSessions(): Session[] {
-    return Array.from(this.sessions.values());
-  }
-
-  /**
-   * Start cleanup interval for expired sessions
-   */
-  private startCleanup(): void {
-    const timeout = config.session?.timeout || 3600; // Default 1 hour
-    const cleanupInterval = 60000; // Check every 1 minute
-
-    this.cleanupInterval = setInterval(() => {
-      this.cleanupExpiredSessions(timeout);
-    }, cleanupInterval);
-
-    logger.info({ timeout, cleanupInterval }, 'Session cleanup started');
-  }
-
-  /**
-   * Stop cleanup interval
-   */
-  stopCleanup(): void {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = undefined;
-      logger.info('Session cleanup stopped');
-    }
-  }
-
-  /**
-   * Cleanup expired sessions
-   */
-  private cleanupExpiredSessions(timeoutSeconds: number): void {
-    const now = Date.now();
-    const expiredSessions: string[] = [];
-
-    for (const [sessionId, session] of this.sessions) {
-      const inactiveTime = (now - session.lastActivity.getTime()) / 1000;
-      if (inactiveTime > timeoutSeconds) {
-        expiredSessions.push(sessionId);
-      }
-    }
-
-    if (expiredSessions.length > 0) {
-      logger.info({ count: expiredSessions.length }, 'Cleaning up expired sessions');
-      for (const sessionId of expiredSessions) {
-        this.closeSession(sessionId);
-      }
-    }
-  }
-
-  /**
-   * Extract user ID from token (simplified)
-   * TODO: Implement proper JWT validation in Stage 5
-   */
-  private extractUserIdFromToken(token: string): string {
-    // For now, use a simple hash or the token itself
-    // In Stage 5, this should decode and validate JWT
-    return token.substring(0, 16);
-  }
-}
-
-// Singleton instance
-export const sessionManager = new SessionManager();

package/src/telemetry/index.ts

@@ -1,10 +0,0 @@
-export { TelemetryManager, telemetry } from './manager.js';
-export type {
-  ResourceCategory,
-  InvocationEvent,
-  SubscribedRule,
-  ConfiguredMcp,
-  TelemetryFile,
-  TelemetryReportPayload,
-  ReportFn,
-} from './manager.js';