@mseep/mcp-agent-social 1.1.0

package/src/hooks/index.ts

@@ -0,0 +1,304 @@
+// ABOUTME: MCP Request/Response Hooks for middleware architecture and custom processing
+// ABOUTME: Provides extensible pipeline for request preprocessing and response enrichment
+
+import { logger } from '../logger.js';
+import { McpRateLimitError } from '../middleware/error-handler.js';
+import {
+  type ErrorHook,
+  type Hook,
+  type HookContext,
+  HookPipeline,
+  HookType,
+  type RequestHook,
+  type ResponseHook,
+} from './types.js';
+
+export class HooksManager {
+  private requestHooks: RequestHook[] = [];
+  private responseHooks: ResponseHook[] = [];
+  private errorHooks: ErrorHook[] = [];
+  private rateLimitWindows: Map<string, number[]> = new Map();
+
+  constructor() {
+    // Register default hooks
+    this.registerDefaultHooks();
+    logger.info('Hooks manager initialized', {
+      requestHooks: this.requestHooks.length,
+      responseHooks: this.responseHooks.length,
+      errorHooks: this.errorHooks.length,
+    });
+  }
+
+  /**
+   * Register a hook
+   */
+  registerHook(hook: Hook): void {
+    switch (hook.type) {
+      case 'request':
+        this.requestHooks.push(hook as RequestHook);
+        this.requestHooks.sort((a, b) => a.priority - b.priority);
+        break;
+      case 'response':
+        this.responseHooks.push(hook as ResponseHook);
+        this.responseHooks.sort((a, b) => a.priority - b.priority);
+        break;
+      case 'error':
+        this.errorHooks.push(hook as ErrorHook);
+        this.errorHooks.sort((a, b) => a.priority - b.priority);
+        break;
+    }
+
+    logger.debug('Registered hook', { name: hook.name, type: hook.type, priority: hook.priority });
+  }
+
+  /**
+   * Process request through all request hooks
+   */
+  async processRequest(request: any, context: HookContext): Promise<any> {
+    let processedRequest = request;
+
+    for (const hook of this.requestHooks) {
+      try {
+        if (hook.condition && !hook.condition(processedRequest, context)) {
+          continue;
+        }
+
+        const result = await hook.execute(processedRequest, context);
+        if (result) {
+          processedRequest = result;
+        }
+
+        logger.debug('Request hook executed', {
+          hookName: hook.name,
+          method: processedRequest.method,
+        });
+      } catch (error) {
+        logger.error('Request hook failed', {
+          hookName: hook.name,
+          error: error instanceof Error ? error.message : String(error),
+        });
+
+        // Don't fail the entire request for hook errors
+        if (hook.critical) {
+          throw error;
+        }
+      }
+    }
+
+    return processedRequest;
+  }
+
+  /**
+   * Process response through all response hooks
+   */
+  async processResponse(response: any, request: any, context: HookContext): Promise<any> {
+    let processedResponse = response;
+
+    for (const hook of this.responseHooks) {
+      try {
+        if (hook.condition && !hook.condition(processedResponse, request, context)) {
+          continue;
+        }
+
+        const result = await hook.execute(processedResponse, request, context);
+        if (result) {
+          processedResponse = result;
+        }
+
+        logger.debug('Response hook executed', {
+          hookName: hook.name,
+          method: request.method,
+        });
+      } catch (error) {
+        logger.error('Response hook failed', {
+          hookName: hook.name,
+          error: error instanceof Error ? error.message : String(error),
+        });
+
+        if (hook.critical) {
+          throw error;
+        }
+      }
+    }
+
+    return processedResponse;
+  }
+
+  /**
+   * Process error through all error hooks
+   */
+  async processError(error: Error, request: any, context: HookContext): Promise<Error> {
+    let processedError = error;
+
+    for (const hook of this.errorHooks) {
+      try {
+        if (hook.condition && !hook.condition(processedError, request, context)) {
+          continue;
+        }
+
+        const result = await hook.execute(processedError, request, context);
+        if (result) {
+          processedError = result;
+        }
+
+        logger.debug('Error hook executed', {
+          hookName: hook.name,
+          originalError: error.message,
+        });
+      } catch (hookError) {
+        logger.error('Error hook failed', {
+          hookName: hook.name,
+          hookError: hookError instanceof Error ? hookError.message : String(hookError),
+        });
+      }
+    }
+
+    return processedError;
+  }
+
+  /**
+   * Register default hooks
+   */
+  private registerDefaultHooks(): void {
+    // Request logging hook
+    this.registerHook({
+      name: 'request-logger',
+      type: 'request',
+      priority: 100,
+      description: 'Log incoming requests',
+      execute: async (request, context) => {
+        logger.info('Processing request', {
+          method: request.method,
+          sessionId: context.sessionId,
+          timestamp: new Date().toISOString(),
+        });
+        return request;
+      },
+    });
+
+    // Response enrichment hook
+    this.registerHook({
+      name: 'response-enricher',
+      type: 'response',
+      priority: 100,
+      description: 'Add metadata to responses',
+      execute: async (response, request, context) => {
+        const enrichedResponse = {
+          ...response,
+          _metadata: {
+            processedAt: new Date().toISOString(),
+            sessionId: context.sessionId,
+            requestMethod: request.method,
+          },
+        };
+        return enrichedResponse;
+      },
+    });
+
+    // Error enrichment hook
+    this.registerHook({
+      name: 'error-enricher',
+      type: 'error',
+      priority: 100,
+      description: 'Enrich errors with context',
+      execute: async (error, request, context) => {
+        const enrichedError = new Error(error.message);
+        enrichedError.name = error.name;
+        enrichedError.stack = error.stack;
+
+        // Add context to error
+        (enrichedError as any).context = {
+          method: request.method,
+          sessionId: context.sessionId,
+          timestamp: new Date().toISOString(),
+        };
+
+        return enrichedError;
+      },
+    });
+
+    // Rate limiting hook with sliding window implementation
+    this.registerHook({
+      name: 'rate-limiter',
+      type: 'request',
+      priority: 10, // High priority - run early
+      description: 'Sliding window rate limiting',
+      critical: true, // Rate limit errors should stop request processing
+      execute: async (request, context) => {
+        const rateLimitKey = `${context.sessionId}:${request.method}`;
+        const now = Date.now();
+        const windowMs = 60000; // 1 minute window
+        const maxRequests = 30; // Standard rate limit
+
+        if (!this.rateLimitWindows) {
+          this.rateLimitWindows = new Map();
+        }
+
+        let requestTimes = this.rateLimitWindows.get(rateLimitKey) || [];
+
+        // Remove requests older than window
+        requestTimes = requestTimes.filter((time) => now - time < windowMs);
+
+        // Check if limit exceeded
+        if (requestTimes.length >= maxRequests) {
+          const oldestRequest = Math.min(...requestTimes);
+          const retryAfter = Math.ceil((oldestRequest + windowMs - now) / 1000);
+
+          logger.warn('Rate limit exceeded', {
+            key: rateLimitKey,
+            requestCount: requestTimes.length,
+            maxRequests,
+            retryAfter,
+          });
+
+          throw new McpRateLimitError(
+            `Rate limit exceeded. Too many ${request.method} requests. Try again in ${retryAfter} seconds.`,
+            retryAfter,
+          );
+        }
+
+        // Add current request time
+        requestTimes.push(now);
+        this.rateLimitWindows.set(rateLimitKey, requestTimes);
+
+        logger.debug('Rate limit check passed', {
+          key: rateLimitKey,
+          currentCount: requestTimes.length,
+          maxRequests,
+        });
+
+        return request;
+      },
+    });
+  }
+
+  /**
+   * Get all registered hooks
+   */
+  getAllHooks(): Hook[] {
+    return [...this.requestHooks, ...this.responseHooks, ...this.errorHooks];
+  }
+
+  /**
+   * Remove a hook by name
+   */
+  removeHook(name: string): boolean {
+    const removeFromArray = (arr: Hook[]) => {
+      const index = arr.findIndex((hook) => hook.name === name);
+      if (index !== -1) {
+        arr.splice(index, 1);
+        return true;
+      }
+      return false;
+    };
+
+    return (
+      removeFromArray(this.requestHooks) ||
+      removeFromArray(this.responseHooks) ||
+      removeFromArray(this.errorHooks)
+    );
+  }
+}
+
+// Global hooks manager instance
+export const hooksManager = new HooksManager();

package/src/hooks/types.ts

@@ -0,0 +1,44 @@
+// ABOUTME: Type definitions for MCP Request/Response Hooks
+// ABOUTME: Defines hook interfaces, context, and pipeline structures
+
+export type HookType = 'request' | 'response' | 'error';
+
+export interface HookContext {
+  sessionId: string;
+  startTime: number;
+  metadata?: Record<string, any>;
+}
+
+export interface BaseHook {
+  name: string;
+  type: HookType;
+  priority: number; // Lower numbers execute first
+  description?: string;
+  critical?: boolean; // If true, hook failures will fail the entire request
+}
+
+export interface RequestHook extends BaseHook {
+  type: 'request';
+  condition?: (request: any, context: HookContext) => boolean;
+  execute: (request: any, context: HookContext) => Promise<any | undefined>;
+}
+
+export interface ResponseHook extends BaseHook {
+  type: 'response';
+  condition?: (response: any, request: any, context: HookContext) => boolean;
+  execute: (response: any, request: any, context: HookContext) => Promise<any | undefined>;
+}
+
+export interface ErrorHook extends BaseHook {
+  type: 'error';
+  condition?: (error: Error, request: any, context: HookContext) => boolean;
+  execute: (error: Error, request: any, context: HookContext) => Promise<Error | undefined>;
+}
+
+export type Hook = RequestHook | ResponseHook | ErrorHook;
+
+export interface HookPipeline {
+  processRequest(request: any, context: HookContext): Promise<any>;
+  processResponse(response: any, request: any, context: HookContext): Promise<any>;
+  processError(error: Error, request: any, context: HookContext): Promise<Error>;
+}

package/src/http-server.ts

@@ -0,0 +1,243 @@
+// ABOUTME: HTTP server implementation for MCP social media server
+// ABOUTME: Provides HTTP/SSE transport as an alternative to stdio
+
+import { randomUUID } from 'node:crypto';
+import { type IncomingMessage, type ServerResponse, createServer } from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { ApiClient } from './api-client.js';
+import { config } from './config.js';
+import { logger } from './logger.js';
+import type { SessionManager } from './session-manager.js';
+
+export interface HttpServerOptions {
+  port?: number;
+  host?: string;
+  enableJsonResponse?: boolean;
+  corsOrigin?: string;
+}
+
+export class HttpMcpServer {
+  private httpServer: ReturnType<typeof createServer> | null = null;
+  private mcpServer: McpServer | null = null;
+  private transport: StreamableHTTPServerTransport | null = null;
+  private readonly options: Required<HttpServerOptions>;
+
+  constructor(
+    private readonly sessionManager: SessionManager,
+    private readonly apiClient: ApiClient,
+    options: HttpServerOptions = {},
+  ) {
+    this.options = {
+      port: options.port ?? 3000,
+      host: options.host ?? 'localhost',
+      enableJsonResponse: options.enableJsonResponse ?? false,
+      corsOrigin: options.corsOrigin ?? '*',
+    };
+  }
+
+  /**
+   * Start the HTTP server
+   */
+  async start(): Promise<void> {
+    if (this.httpServer) {
+      throw new Error('HTTP server already started');
+    }
+
+    // Create single MCP server instance
+    await this.createMcpServer();
+
+    this.httpServer = createServer(async (req, res) => {
+      // Add CORS headers
+      res.setHeader('Access-Control-Allow-Origin', this.options.corsOrigin);
+      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Mcp-Session-Id');
+      res.setHeader('Access-Control-Max-Age', '86400');
+
+      // Handle preflight requests
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+
+      // Log request
+      logger.debug('HTTP request received', {
+        method: req.method,
+        url: req.url,
+        headers: req.headers,
+      });
+
+      try {
+        await this.handleRequest(req, res);
+      } catch (error) {
+        logger.error('Error handling HTTP request', { error });
+        if (!res.headersSent) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+      }
+    });
+
+    return new Promise((resolve, reject) => {
+      this.httpServer?.listen(this.options.port, this.options.host, () => {
+        logger.info('HTTP MCP server started', {
+          host: this.options.host,
+          port: this.options.port,
+          enableJsonResponse: this.options.enableJsonResponse,
+        });
+        resolve();
+      });
+
+      this.httpServer?.on('error', (error) => {
+        logger.error('HTTP server error', { error });
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Stop the HTTP server
+   */
+  async stop(): Promise<void> {
+    if (!this.httpServer) {
+      return;
+    }
+
+    // Close MCP server connection
+    if (this.mcpServer) {
+      try {
+        await this.mcpServer.close();
+        logger.debug('Closed MCP server');
+      } catch (error) {
+        logger.error('Error closing MCP server', { error });
+      }
+      this.mcpServer = null;
+      this.transport = null;
+    }
+
+    // Close HTTP server
+    return new Promise((resolve, reject) => {
+      this.httpServer?.close((error) => {
+        if (error) {
+          logger.error('Error closing HTTP server', { error });
+          reject(error);
+        } else {
+          logger.info('HTTP MCP server stopped');
+          this.httpServer = null;
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * Handle incoming HTTP requests
+   */
+  private async handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    const url = new URL(req.url || '/', `http://${req.headers.host}`);
+
+    // Only handle requests to /mcp endpoint
+    if (url.pathname !== '/mcp') {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Not found' }));
+      return;
+    }
+
+    // Get or create session ID
+    const sessionId = (req.headers['mcp-session-id'] as string) || randomUUID();
+
+    // Set session ID in response header for client tracking
+    res.setHeader('Mcp-Session-Id', sessionId);
+
+    if (!this.transport) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Transport not found' }));
+      return;
+    }
+
+    // Parse body if POST
+    let body: unknown;
+    if (req.method === 'POST') {
+      body = await this.parseRequestBody(req);
+    }
+
+    // Let transport handle the request
+    await this.transport.handleRequest(req, res, body);
+  }
+
+  /**
+   * Create the MCP server instance with HTTP transport
+   */
+  private async createMcpServer(): Promise<void> {
+    // Import the registration functions dynamically to avoid circular dependencies
+    const { hooksManager } = await import('./hooks/index.js');
+    const { registerPrompts } = await import('./prompts/index.js');
+    const { registerResources } = await import('./resources/index.js');
+    const { registerRoots } = await import('./roots/index.js');
+    const { registerTools } = await import('./tools/index.js');
+
+    // Import version from config
+    const { version } = await import('./config.js');
+
+    // Create MCP server
+    this.mcpServer = new McpServer({
+      name: 'mcp-agent-social',
+      version,
+    });
+
+    // Create HTTP transport
+    this.transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: randomUUID,
+      enableJsonResponse: this.options.enableJsonResponse,
+      onsessioninitialized: (id) => {
+        logger.debug('Session initialized', { sessionId: id });
+      },
+    });
+
+    // Register all capabilities
+    registerTools(this.mcpServer, {
+      sessionManager: this.sessionManager,
+      apiClient: this.apiClient,
+      hooksManager,
+    });
+    registerResources(this.mcpServer, {
+      apiClient: this.apiClient,
+      sessionManager: this.sessionManager,
+      hooksManager,
+    });
+    registerPrompts(this.mcpServer, {
+      apiClient: this.apiClient,
+      sessionManager: this.sessionManager,
+      hooksManager,
+    });
+    registerRoots(this.mcpServer, {
+      apiClient: this.apiClient,
+      sessionManager: this.sessionManager,
+      hooksManager,
+    });
+
+    // Connect transport
+    await this.mcpServer.connect(this.transport);
+  }
+
+  /**
+   * Parse request body as JSON
+   */
+  private async parseRequestBody(req: IncomingMessage): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      let body = '';
+      req.on('data', (chunk) => {
+        body += chunk.toString();
+      });
+      req.on('end', () => {
+        try {
+          resolve(body ? JSON.parse(body) : undefined);
+        } catch (_error) {
+          reject(new Error('Invalid JSON body'));
+        }
+      });
+      req.on('error', reject);
+    });
+  }
+}