@mickdarling/dollhousemcp/dist/src/marketplace/GitHubClient.js

DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.

/**
 * GitHub API client for marketplace integration
 */
import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
import { SECURITY_LIMITS } from '../security/constants.js';
import { SecureTokenManager, TokenScope } from '../security/tokenManager.js';
export class GitHubClient {
    apiCache;
    rateLimitTracker;
    constructor(apiCache, rateLimitTracker) {
        this.apiCache = apiCache;
        this.rateLimitTracker = rateLimitTracker;
    }
    /**
     * Check rate limit for API calls
     */
    checkRateLimit(key = 'default') {
        const now = Date.now();
        const requests = this.rateLimitTracker.get(key) || [];
        // Remove requests outside the window
        const validRequests = requests.filter(time => now - time < SECURITY_LIMITS.RATE_LIMIT_WINDOW_MS);
        if (validRequests.length >= SECURITY_LIMITS.RATE_LIMIT_REQUESTS) {
            throw new Error(`Rate limit exceeded. Max ${SECURITY_LIMITS.RATE_LIMIT_REQUESTS} requests per minute.`);
        }
        validRequests.push(now);
        this.rateLimitTracker.set(key, validRequests);
    }
    /**
     * Fetch data from GitHub API with caching and rate limiting
     */
    async fetchFromGitHub(url) {
        try {
            // Check rate limit
            this.checkRateLimit('github_api');
            // Check cache first
            const cached = this.apiCache.get(url);
            if (cached) {
                return cached;
            }
            // Add GitHub token if available for higher rate limits
            const headers = {
                'Accept': 'application/vnd.github.v3+json',
                'User-Agent': 'DollhouseMCP/1.0'
            };
            // Use SecureTokenManager for token handling if token is available
            if (process.env.GITHUB_TOKEN) {
                try {
                    const token = await SecureTokenManager.getSecureGitHubToken(TokenScope.READ);
                    headers['Authorization'] = `Bearer ${token}`;
                }
                catch (tokenError) {
                    // Log error but continue without token
                    console.log('GitHub token validation failed, proceeding without authentication');
                }
            }
            // Create fetch with timeout
            const controller = new AbortController();
            const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
            const response = await fetch(url, {
                headers,
                signal: controller.signal
            });
            clearTimeout(timeoutId);
            if (!response.ok) {
                if (response.status === 403) {
                    throw new Error('GitHub API rate limit exceeded. Consider setting GITHUB_TOKEN environment variable.');
                }
                throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
            }
            const data = await response.json();
            // Cache the successful response
            this.apiCache.set(url, data);
            return data;
        }
        catch (error) {
            // Preserve original error information with proper error chaining
            const errorMessage = error instanceof Error ? error.message : String(error);
            const errorDetails = {
                originalMessage: errorMessage,
                url
            };
            // Preserve stack trace and error type information
            if (error instanceof Error) {
                errorDetails.errorType = error.constructor.name;
                errorDetails.stack = error.stack;
                // Special handling for common error types
                if (error.name === 'AbortError') {
                    errorDetails.timeout = true;
                }
            }
            const mcpError = new McpError(ErrorCode.InternalError, `Failed to fetch from GitHub: ${errorMessage}`, errorDetails);
            // Also preserve original error for debugging
            mcpError.cause = error;
            throw mcpError;
        }
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GitHubClient.js","sourceRoot":"","sources":["../../../src/marketplace/GitHubClient.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GitHub API client for marketplace integration\n */\n\nimport { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';\nimport { APICache } from '../cache/APICache.js';\nimport { SECURITY_LIMITS } from '../security/constants.js';\nimport { SecureTokenManager, TokenScope } from '../security/tokenManager.js';\n\nexport class GitHubClient {\n  private apiCache: APICache;\n  private rateLimitTracker: Map<string, number[]>;\n  \n  constructor(apiCache: APICache, rateLimitTracker: Map<string, number[]>) {\n    this.apiCache = apiCache;\n    this.rateLimitTracker = rateLimitTracker;\n  }\n  \n  /**\n   * Check rate limit for API calls\n   */\n  private checkRateLimit(key: string = 'default'): void {\n    const now = Date.now();\n    const requests = this.rateLimitTracker.get(key) || [];\n    \n    // Remove requests outside the window\n    const validRequests = requests.filter(time => now - time < SECURITY_LIMITS.RATE_LIMIT_WINDOW_MS);\n    \n    if (validRequests.length >= SECURITY_LIMITS.RATE_LIMIT_REQUESTS) {\n      throw new Error(`Rate limit exceeded. Max ${SECURITY_LIMITS.RATE_LIMIT_REQUESTS} requests per minute.`);\n    }\n    \n    validRequests.push(now);\n    this.rateLimitTracker.set(key, validRequests);\n  }\n  \n  /**\n   * Fetch data from GitHub API with caching and rate limiting\n   */\n  async fetchFromGitHub(url: string): Promise<any> {\n    try {\n      // Check rate limit\n      this.checkRateLimit('github_api');\n      \n      // Check cache first\n      const cached = this.apiCache.get(url);\n      if (cached) {\n        return cached;\n      }\n      \n      // Add GitHub token if available for higher rate limits\n      const headers: Record<string, string> = {\n        'Accept': 'application/vnd.github.v3+json',\n        'User-Agent': 'DollhouseMCP/1.0'\n      };\n      \n      // Use SecureTokenManager for token handling if token is available\n      if (process.env.GITHUB_TOKEN) {\n        try {\n          const token = await SecureTokenManager.getSecureGitHubToken(TokenScope.READ);\n          headers['Authorization'] = `Bearer ${token}`;\n        } catch (tokenError) {\n          // Log error but continue without token\n          console.log('GitHub token validation failed, proceeding without authentication');\n        }\n      }\n      \n      // Create fetch with timeout\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout\n      \n      const response = await fetch(url, {\n        headers,\n        signal: controller.signal\n      });\n      \n      clearTimeout(timeoutId);\n      \n      if (!response.ok) {\n        if (response.status === 403) {\n          throw new Error('GitHub API rate limit exceeded. Consider setting GITHUB_TOKEN environment variable.');\n        }\n        throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);\n      }\n      \n      const data = await response.json();\n      \n      // Cache the successful response\n      this.apiCache.set(url, data);\n      \n      return data;\n    } catch (error) {\n      // Preserve original error information with proper error chaining\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      const errorDetails: any = {\n        originalMessage: errorMessage,\n        url\n      };\n      \n      // Preserve stack trace and error type information\n      if (error instanceof Error) {\n        errorDetails.errorType = error.constructor.name;\n        errorDetails.stack = error.stack;\n        \n        // Special handling for common error types\n        if (error.name === 'AbortError') {\n          errorDetails.timeout = true;\n        }\n      }\n      \n      const mcpError = new McpError(\n        ErrorCode.InternalError,\n        `Failed to fetch from GitHub: ${errorMessage}`,\n        errorDetails\n      );\n      \n      // Also preserve original error for debugging\n      (mcpError as any).cause = error;\n      \n      throw mcpError;\n    }\n  }\n}"]}