@elliotding/ai-agent-mcp 0.1.0

package/src/session/manager.ts

@@ -0,0 +1,296 @@
+/**
+ * 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/tools/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Tools Index
+ * Exports all MCP tools
+ */
+
+export * from './sync-resources';
+export * from './manage-subscription';
+export * from './search-resources';
+export * from './upload-resource';
+export * from './uninstall-resource';
+export * from './registry';

package/src/tools/manage-subscription.ts

@@ -0,0 +1,332 @@
+/**
+ * manage_subscription Tool
+ * Manage resource subscriptions
+ */
+
+import { logger, logToolCall } from '../utils/logger';
+import { apiClient } from '../api/client';
+import { MCPServerError, createValidationError } from '../types/errors';
+import type { ManageSubscriptionParams, ManageSubscriptionResult, ToolResult } from '../types/tools';
+import { syncResources } from './sync-resources';
+import { uninstallResource } from './uninstall-resource';
+
+export async function manageSubscription(params: unknown): Promise<ToolResult<ManageSubscriptionResult>> {
+  const startTime = Date.now();
+
+  // Type assertion for params
+  const typedParams = params as ManageSubscriptionParams;
+
+  logger.info({ tool: 'manage_subscription', params }, 'manage_subscription called');
+
+  try {
+    let result: ManageSubscriptionResult;
+
+    switch (typedParams.action) {
+      case 'subscribe': {
+        // Validate resource_ids
+        if (!typedParams.resource_ids || typedParams.resource_ids.length === 0) {
+          throw createValidationError(
+            'resource_ids',
+            'array',
+            'resource_ids is required for subscribe action'
+          );
+        }
+
+        logger.debug({ resourceIds: typedParams.resource_ids, autoSync: typedParams.auto_sync }, 'Subscribing to resources...');
+
+        // Subscribe to resources
+        const subResult = await apiClient.subscribe(
+          typedParams.resource_ids,
+          typedParams.auto_sync
+        );
+
+        logger.info({ count: subResult.subscriptions.length }, 'Resources subscribed successfully');
+
+        // Auto-sync newly subscribed resources immediately (default: true)
+        const shouldAutoSync = typedParams.auto_sync !== false;
+        let syncSummary: string | undefined;
+        let syncDetails: Array<{ id: string; name: string; action: string }> | undefined;
+        let pendingSetup: unknown[] | undefined;
+
+        if (shouldAutoSync && subResult.subscriptions.length > 0) {
+          logger.info({ resourceIds: typedParams.resource_ids }, 'Auto-syncing newly subscribed resources...');
+          const syncResult = await syncResources({ mode: 'incremental', scope: typedParams.scope || 'global' });
+          if (syncResult.success && syncResult.data) {
+            const sd = syncResult.data;
+            syncSummary = `Auto-sync: ${sd.summary.synced} synced, ${sd.summary.cached} cached, ${sd.summary.failed} failed`;
+            syncDetails = sd.details.map(d => ({ id: d.id, name: d.name, action: d.action }));
+            if (sd.pending_setup && sd.pending_setup.length > 0) {
+              pendingSetup = sd.pending_setup;
+            }
+            logger.info({ summary: sd.summary }, 'Auto-sync after subscribe completed');
+          } else {
+            logger.warn({ error: syncResult.error }, 'Auto-sync after subscribe failed, subscription still recorded');
+            syncSummary = 'Auto-sync failed — run sync_resources manually if needed';
+          }
+        }
+
+        result = {
+          action: 'subscribe',
+          success: true,
+          subscriptions: subResult.subscriptions.map(sub => ({
+            id: sub.id,
+            name: sub.name,
+            type: sub.type,
+            subscribed_at: sub.subscribed_at,
+          })),
+          message: [
+            `Successfully subscribed to ${subResult.subscriptions.length} resource${subResult.subscriptions.length > 1 ? 's' : ''}.`,
+            syncSummary,
+          ].filter(Boolean).join(' '),
+          ...(syncDetails ? { sync_details: syncDetails } : {}),
+          ...(pendingSetup ? { pending_setup: pendingSetup } : {}),
+        };
+        break;
+      }
+
+      case 'unsubscribe': {
+        // Validate resource_ids
+        if (!typedParams.resource_ids || typedParams.resource_ids.length === 0) {
+          throw createValidationError(
+            'resource_ids',
+            'array',
+            'resource_ids is required for unsubscribe action'
+          );
+        }
+
+        logger.debug({ resourceIds: typedParams.resource_ids }, 'Unsubscribing from resources...');
+
+        // Cancel server-side subscription
+        await apiClient.unsubscribe(typedParams.resource_ids);
+        logger.info({ count: typedParams.resource_ids.length }, 'Server-side subscriptions removed');
+
+        // Uninstall local files and MCP config for each resource
+        const uninstallResults: Array<{ id: string; removed: boolean; detail: string }> = [];
+        for (const resourceId of typedParams.resource_ids) {
+          // Use the last segment of the resource ID as the search pattern
+          // e.g. "mcp-client-sdk-ai-hub-jenkins" → "jenkins"
+          //      "rule-csp-elliotTest"            → "elliotTest"
+          const namePart = resourceId.split('-').slice(-1)[0] ||
+                           resourceId.split('-').slice(-2).join('-') ||
+                           resourceId;
+
+          // Try full name match first (e.g. "elliotTest"), fallback to last segment
+          const patternsToTry = Array.from(new Set([
+            resourceId,                                   // full id
+            resourceId.replace(/^(skill|cmd|rule|mcp)-[^-]+-/, ''), // strip prefix+source
+            namePart,
+          ]));
+
+          let uninstalled = false;
+          for (const pattern of patternsToTry) {
+            const uninstallResult = await uninstallResource({
+              resource_id_or_name: pattern,
+              remove_from_account: false, // already unsubscribed above
+            });
+            if (uninstallResult.success && uninstallResult.data && uninstallResult.data.removed_resources.length > 0) {
+              uninstallResults.push({ id: resourceId, removed: true, detail: `Removed local files for "${pattern}"` });
+              uninstalled = true;
+              break;
+            }
+          }
+          if (!uninstalled) {
+            uninstallResults.push({ id: resourceId, removed: false, detail: 'No local files found (may not have been installed)' });
+          }
+        }
+
+        const removedCount = uninstallResults.filter(r => r.removed).length;
+        const notFoundCount = uninstallResults.filter(r => !r.removed).length;
+
+        result = {
+          action: 'unsubscribe',
+          success: true,
+          message: [
+            `Successfully unsubscribed from ${typedParams.resource_ids.length} resource${typedParams.resource_ids.length > 1 ? 's' : ''}.`,
+            removedCount > 0 ? `Removed local files for ${removedCount} resource${removedCount > 1 ? 's' : ''}.` : null,
+            notFoundCount > 0 ? `${notFoundCount} resource${notFoundCount > 1 ? 's were' : ' was'} not installed locally.` : null,
+          ].filter(Boolean).join(' '),
+          sync_details: uninstallResults.map(r => ({ id: r.id, name: r.id, action: r.removed ? 'uninstalled' : 'not_found_locally' })),
+        };
+
+        logger.info({ count: typedParams.resource_ids.length, removedCount }, 'Resources unsubscribed and local files cleaned up');
+        break;
+      }
+
+      case 'list': {
+        logger.debug({ scope: typedParams.scope || 'all' }, 'Listing subscriptions...');
+
+        // Get subscriptions list
+        const subs = await apiClient.getSubscriptions({});
+
+        result = {
+          action: 'list',
+          success: true,
+          subscriptions: subs.subscriptions.map(sub => ({
+            id: sub.id,
+            name: sub.name,
+            type: sub.type,
+            subscribed_at: sub.subscribed_at,
+          })),
+          message: `Found ${subs.total} subscription${subs.total !== 1 ? 's' : ''}`,
+        };
+
+        logger.info({ total: subs.total }, 'Subscriptions listed successfully');
+        break;
+      }
+
+      case 'batch_subscribe': {
+        // Validate resource_ids
+        if (!typedParams.resource_ids || typedParams.resource_ids.length === 0) {
+          throw createValidationError(
+            'resource_ids',
+            'array',
+            'resource_ids is required for batch_subscribe action'
+          );
+        }
+
+        logger.debug({ count: typedParams.resource_ids.length, autoSync: typedParams.auto_sync }, 'Batch subscribing to resources...');
+
+        const batchSubResult = await apiClient.subscribe(
+          typedParams.resource_ids,
+          typedParams.auto_sync
+        );
+
+        logger.info({ count: batchSubResult.subscriptions.length }, 'Batch subscription completed');
+
+        // Auto-sync newly subscribed resources immediately (default: true)
+        const shouldBatchAutoSync = typedParams.auto_sync !== false;
+        let batchSyncSummary: string | undefined;
+        let batchSyncDetails: Array<{ id: string; name: string; action: string }> | undefined;
+        let batchPendingSetup: unknown[] | undefined;
+
+        if (shouldBatchAutoSync && batchSubResult.subscriptions.length > 0) {
+          logger.info({ count: batchSubResult.subscriptions.length }, 'Auto-syncing batch subscribed resources...');
+          const batchSyncResult = await syncResources({ mode: 'incremental', scope: typedParams.scope || 'global' });
+          if (batchSyncResult.success && batchSyncResult.data) {
+            const sd = batchSyncResult.data;
+            batchSyncSummary = `Auto-sync: ${sd.summary.synced} synced, ${sd.summary.cached} cached, ${sd.summary.failed} failed`;
+            batchSyncDetails = sd.details.map(d => ({ id: d.id, name: d.name, action: d.action }));
+            if (sd.pending_setup && sd.pending_setup.length > 0) {
+              batchPendingSetup = sd.pending_setup;
+            }
+          } else {
+            batchSyncSummary = 'Auto-sync failed — run sync_resources manually if needed';
+          }
+        }
+
+        result = {
+          action: 'batch_subscribe',
+          success: true,
+          subscriptions: batchSubResult.subscriptions.map(sub => ({
+            id: sub.id,
+            name: sub.name,
+            type: sub.type,
+            subscribed_at: sub.subscribed_at,
+          })),
+          message: [
+            `Successfully batch subscribed to ${batchSubResult.subscriptions.length} resource${batchSubResult.subscriptions.length > 1 ? 's' : ''}.`,
+            batchSyncSummary,
+          ].filter(Boolean).join(' '),
+          ...(batchSyncDetails ? { sync_details: batchSyncDetails } : {}),
+          ...(batchPendingSetup ? { pending_setup: batchPendingSetup } : {}),
+        };
+        break;
+      }
+
+      case 'batch_unsubscribe': {
+        // Validate resource_ids
+        if (!typedParams.resource_ids || typedParams.resource_ids.length === 0) {
+          throw createValidationError(
+            'resource_ids',
+            'array',
+            'resource_ids is required for batch_unsubscribe action'
+          );
+        }
+
+        logger.debug({ count: typedParams.resource_ids.length }, 'Batch unsubscribing from resources...');
+
+        // Delegate entirely to the unsubscribe case for unified cleanup logic
+        return manageSubscription({ ...typedParams, action: 'unsubscribe' });
+      }
+
+      default: {
+        throw createValidationError(
+          'action',
+          'string',
+          `Unknown action. Must be one of: subscribe, unsubscribe, list, batch_subscribe, batch_unsubscribe`
+        );
+      }
+    }
+
+    const duration = Date.now() - startTime;
+    logToolCall('manage_subscription', 'user-id', params as Record<string, unknown>, duration);
+
+    logger.info(
+      {
+        action: typedParams.action,
+        duration,
+      },
+      'manage_subscription completed successfully'
+    );
+
+    return {
+      success: true,
+      data: result,
+    };
+  } catch (error) {
+    logger.error({ error, action: typedParams.action }, 'manage_subscription failed');
+    return {
+      success: false,
+      error: {
+        code: error instanceof MCPServerError ? error.code : 'UNKNOWN_ERROR',
+        message: error instanceof Error ? error.message : String(error),
+      },
+    };
+  }
+}
+
+// Tool definition for registry
+export const manageSubscriptionTool = {
+  name: 'manage_subscription',
+  description:
+    'Manage resource subscriptions (subscribe, unsubscribe, list). ' +
+    'When action is "subscribe" or "batch_subscribe", the tool automatically syncs ' +
+    'the newly subscribed resources to the local machine immediately after subscribing ' +
+    '(auto_sync defaults to true). Pass auto_sync: false only when the user explicitly ' +
+    'says they do NOT want the resource installed right now.',
+  inputSchema: {
+    type: 'object' as const,
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Action to perform',
+        enum: ['subscribe', 'unsubscribe', 'list', 'batch_subscribe', 'batch_unsubscribe'],
+      },
+      resource_ids: {
+        type: 'array',
+        description: 'Resource IDs (required for subscribe/unsubscribe actions)',
+      },
+      auto_sync: {
+        type: 'boolean',
+        description:
+          'Whether to immediately sync (install) the subscribed resources to the local machine after subscribing. ' +
+          'Defaults to true — omit this field in normal usage. ' +
+          'Set to false only when the user explicitly says they want to subscribe but NOT install yet.',
+        default: true,
+      },
+      scope: {
+        type: 'string',
+        description: 'Installation scope',
+        enum: ['global', 'workspace'],
+        default: 'global',
+      },
+      notify: {
+        type: 'boolean',
+        description: 'Enable update notifications',
+        default: true,
+      },
+    },
+    required: ['action'],
+  },
+  handler: manageSubscription,
+};