@dollhousemcp/mcp-server 1.4.4 → 1.5.0

package/dist/auth/GitHubAuthManager.js

@@ -0,0 +1,465 @@
+/**
+ * GitHub authentication manager using OAuth device flow
+ * Handles authentication for MCP servers without requiring client secrets
+ */
+import { TokenManager } from '../security/tokenManager.js';
+import { logger } from '../utils/logger.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+/**
+ * Manages GitHub authentication using the OAuth device flow
+ * This is the recommended approach for CLI/desktop applications
+ */
+export class GitHubAuthManager {
+    // GitHub OAuth App Client ID for DollhouseMCP
+    // Must be configured via environment variable
+    static CLIENT_ID = process.env.DOLLHOUSE_GITHUB_CLIENT_ID;
+    // GitHub OAuth endpoints
+    static DEVICE_CODE_URL = 'https://github.com/login/device/code';
+    static TOKEN_URL = 'https://github.com/login/oauth/access_token';
+    static USER_URL = 'https://api.github.com/user';
+    // Polling configuration
+    static DEFAULT_POLL_INTERVAL = 5000; // 5 seconds
+    static MAX_POLL_ATTEMPTS = 180; // 15 minutes total
+    apiCache;
+    activePolling = null;
+    constructor(apiCache) {
+        this.apiCache = apiCache;
+    }
+    /**
+     * Execute a network request with retry logic
+     */
+    async fetchWithRetry(url, options, maxRetries = 3, retryDelay = 1000) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await fetch(url, options);
+                return response;
+            }
+            catch (error) {
+                lastError = error;
+                // Check if it's a network error that should be retried
+                const isNetworkError = error instanceof Error && (error.message.includes('ECONNREFUSED') ||
+                    error.message.includes('ETIMEDOUT') ||
+                    error.message.includes('ENOTFOUND') ||
+                    error.message.includes('network'));
+                if (isNetworkError && attempt < maxRetries) {
+                    logger.debug(`Network request failed, retrying (${attempt}/${maxRetries})`, {
+                        url,
+                        error: error.message,
+                        nextRetryIn: retryDelay * attempt
+                    });
+                    // Exponential backoff
+                    await new Promise(resolve => setTimeout(resolve, retryDelay * attempt));
+                }
+                else {
+                    // Not a network error or last attempt, throw immediately
+                    throw error;
+                }
+            }
+        }
+        throw lastError || new Error('Network request failed after all retries');
+    }
+    /**
+     * Check current authentication status
+     */
+    async getAuthStatus() {
+        const token = await TokenManager.getGitHubTokenAsync();
+        if (!token) {
+            return {
+                isAuthenticated: false,
+                hasToken: false
+            };
+        }
+        try {
+            // Try to get user info to validate token
+            const userInfo = await this.fetchUserInfo(token);
+            return {
+                isAuthenticated: true,
+                hasToken: true,
+                username: userInfo.login,
+                scopes: userInfo.scopes
+            };
+        }
+        catch (error) {
+            // Token might be invalid or expired
+            logger.debug('Token validation failed', { error });
+            return {
+                isAuthenticated: false,
+                hasToken: true // Has token but it's invalid
+            };
+        }
+    }
+    /**
+     * Initiate the device flow authentication process
+     */
+    async initiateDeviceFlow() {
+        if (!GitHubAuthManager.CLIENT_ID) {
+            throw new Error('GitHub OAuth is not configured. Please set DOLLHOUSE_GITHUB_CLIENT_ID environment variable. ' +
+                'Register an OAuth app at https://github.com/settings/applications/new');
+        }
+        try {
+            const response = await this.fetchWithRetry(GitHubAuthManager.DEVICE_CODE_URL, {
+                method: 'POST',
+                headers: {
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    client_id: GitHubAuthManager.CLIENT_ID,
+                    scope: 'public_repo read:user'
+                })
+            });
+            if (!response.ok) {
+                // Provide user-friendly error messages based on status codes
+                const errorMessage = this.getErrorMessageForStatus(response.status, 'device flow initialization');
+                logger.debug('Device flow initiation failed', {
+                    status: response.status,
+                    statusText: response.statusText
+                });
+                throw new Error(errorMessage);
+            }
+            const data = await response.json();
+            // Validate response
+            if (!data.device_code || !data.user_code || !data.verification_uri) {
+                throw new Error('Invalid device flow response from GitHub');
+            }
+            // Log security event for audit trail
+            SecurityMonitor.logSecurityEvent({
+                type: 'TOKEN_VALIDATION_SUCCESS',
+                severity: 'LOW',
+                source: 'GitHubAuthManager.initiateDeviceFlow',
+                details: 'GitHub OAuth device flow initiated',
+                metadata: {
+                    userCode: data.user_code,
+                    expiresIn: data.expires_in,
+                    interval: data.interval
+                }
+            });
+            return data;
+        }
+        catch (error) {
+            logger.error('Failed to initiate device flow', { error });
+            throw new Error('Failed to start GitHub authentication. Please check your internet connection.');
+        }
+    }
+    /**
+     * Poll for token after user has authorized the device
+     */
+    async pollForToken(deviceCode, interval = GitHubAuthManager.DEFAULT_POLL_INTERVAL) {
+        // Create new abort controller for this polling session
+        this.activePolling = new AbortController();
+        const signal = this.activePolling.signal;
+        let attempts = 0;
+        try {
+            while (attempts < GitHubAuthManager.MAX_POLL_ATTEMPTS) {
+                // Check if polling was aborted
+                if (signal.aborted) {
+                    throw new Error('Authentication polling was cancelled');
+                }
+                attempts++;
+                try {
+                    const response = await fetch(GitHubAuthManager.TOKEN_URL, {
+                        method: 'POST',
+                        headers: {
+                            'Accept': 'application/json',
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            client_id: GitHubAuthManager.CLIENT_ID,
+                            device_code: deviceCode,
+                            grant_type: 'urn:ietf:params:oauth:grant-type:device_code'
+                        })
+                    });
+                    const data = await response.json();
+                    // Check for various response states
+                    if (data.error) {
+                        switch (data.error) {
+                            case 'authorization_pending':
+                                // User hasn't authorized yet, keep polling
+                                break;
+                            case 'slow_down':
+                                // Increase polling interval
+                                interval = Math.min(interval * 1.5, 30000); // Max 30 seconds
+                                logger.debug('Slowing down polling interval', { newInterval: interval });
+                                break;
+                            case 'expired_token':
+                                throw new Error('The authorization code has expired. Please start over.');
+                            case 'access_denied':
+                                throw new Error('Authorization was denied. Please try again.');
+                            default:
+                                // Log the actual error for debugging
+                                logger.debug('OAuth device flow error', {
+                                    error: data.error,
+                                    description: data.error_description
+                                });
+                                throw new Error('Authentication failed. Please try starting the process again.');
+                        }
+                    }
+                    else if (data.access_token) {
+                        // Success!
+                        return data;
+                    }
+                    // Wait before next poll
+                    // Wait for interval with abort support
+                    await this.waitWithAbort(interval, signal);
+                }
+                catch (error) {
+                    // Network errors shouldn't stop polling
+                    logger.debug('Poll attempt failed', { attempt: attempts, error });
+                    await this.waitWithAbort(interval, signal);
+                }
+            }
+            throw new Error('Authentication timed out. Please try again.');
+        }
+        finally {
+            // Clear active polling reference
+            this.activePolling = null;
+        }
+    }
+    /**
+     * Complete the authentication flow and store the token
+     */
+    async completeAuthentication(tokenResponse) {
+        // Store token securely
+        await this.storeToken(tokenResponse.access_token);
+        // Get user info
+        const userInfo = await this.fetchUserInfo(tokenResponse.access_token);
+        // Log successful authentication completion
+        SecurityMonitor.logSecurityEvent({
+            type: 'TOKEN_VALIDATION_SUCCESS',
+            severity: 'LOW',
+            source: 'GitHubAuthManager.completeAuthentication',
+            details: 'GitHub OAuth device flow completed successfully',
+            metadata: {
+                username: userInfo.login,
+                scopes: tokenResponse.scope.split(' '),
+                tokenType: TokenManager.getTokenType(tokenResponse.access_token)
+            }
+        });
+        return {
+            isAuthenticated: true,
+            hasToken: true,
+            username: userInfo.login,
+            scopes: tokenResponse.scope.split(' ')
+        };
+    }
+    /**
+     * Clear stored authentication and revoke token
+     */
+    async clearAuthentication() {
+        try {
+            // Get the token before clearing it
+            const token = await TokenManager.getGitHubTokenAsync();
+            if (token) {
+                // Attempt to revoke the token on GitHub
+                // Note: GitHub OAuth tokens don't have a revocation endpoint for device flow tokens
+                // But we'll clear the cache and remove from storage
+                // Clear cached user info
+                this.apiCache.clear();
+                // Log security event for audit trail
+                SecurityMonitor.logSecurityEvent({
+                    type: 'TOKEN_CACHE_CLEARED',
+                    severity: 'LOW',
+                    source: 'GitHubAuthManager.clearAuthentication',
+                    details: 'GitHub authentication cleared by user request',
+                    metadata: {
+                        hadToken: true,
+                        tokenPrefix: TokenManager.getTokenPrefix(token)
+                    }
+                });
+            }
+            // Remove from secure storage
+            await TokenManager.removeStoredToken();
+            logger.info('GitHub authentication cleared successfully');
+        }
+        catch (error) {
+            logger.error('Error clearing authentication', { error });
+            throw new Error('Failed to clear authentication');
+        }
+    }
+    /**
+     * Store token securely using encrypted file storage
+     */
+    async storeToken(token) {
+        try {
+            await TokenManager.storeGitHubToken(token);
+            logger.info('GitHub token stored securely. You are now authenticated!');
+        }
+        catch (error) {
+            logger.error('Failed to store token securely', { error });
+            // Fallback to environment variable instructions
+            logger.info('For manual setup, you can set GITHUB_TOKEN environment variable.');
+            throw error;
+        }
+    }
+    /**
+     * Fetch user information from GitHub
+     */
+    async fetchUserInfo(token) {
+        // Check cache first
+        const cached = this.apiCache.get(GitHubAuthManager.USER_URL);
+        if (cached) {
+            return cached;
+        }
+        const response = await this.fetchWithRetry(GitHubAuthManager.USER_URL, {
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Accept': 'application/vnd.github.v3+json'
+            }
+        });
+        if (!response.ok) {
+            const errorMessage = this.getErrorMessageForStatus(response.status, 'user information fetch');
+            logger.debug('Failed to fetch user info', { status: response.status });
+            throw new Error(errorMessage);
+        }
+        const data = await response.json();
+        // Normalize username and other text fields to prevent Unicode attacks
+        if (data.login) {
+            const validation = UnicodeValidator.normalize(data.login);
+            if (!validation.isValid) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'UNICODE_VALIDATION_ERROR',
+                    severity: 'MEDIUM',
+                    source: 'GitHubAuthManager.fetchUserInfo',
+                    details: 'GitHub username contains invalid Unicode',
+                    metadata: {
+                        originalLength: data.login.length,
+                        detectedIssues: validation.detectedIssues
+                    }
+                });
+                throw new Error('Invalid username format from GitHub');
+            }
+            data.login = validation.normalizedContent;
+        }
+        // Normalize display name if present
+        if (data.name) {
+            const nameValidation = UnicodeValidator.normalize(data.name);
+            if (nameValidation.isValid) {
+                data.name = nameValidation.normalizedContent;
+            }
+            else {
+                // Don't fail on display name, just remove it
+                delete data.name;
+            }
+        }
+        // Add scopes from response headers
+        const scopeHeader = response.headers.get('x-oauth-scopes');
+        if (scopeHeader) {
+            data.scopes = scopeHeader.split(',').map(s => s.trim());
+        }
+        // Log successful authentication for audit trail
+        SecurityMonitor.logSecurityEvent({
+            type: 'TOKEN_VALIDATION_SUCCESS',
+            severity: 'LOW',
+            source: 'GitHubAuthManager.fetchUserInfo',
+            details: 'GitHub user authenticated successfully',
+            metadata: {
+                username: data.login,
+                hasEmail: !!data.email,
+                scopes: data.scopes || []
+            }
+        });
+        // Cache the result
+        this.apiCache.set(GitHubAuthManager.USER_URL, data);
+        return data;
+    }
+    /**
+     * Format authentication instructions for users
+     */
+    formatAuthInstructions(deviceResponse) {
+        return `🔐 **GitHub Authentication Required**
+
+To access all DollhouseMCP features, please authenticate with GitHub:
+
+1. Visit: **${deviceResponse.verification_uri}**
+2. Enter code: **${deviceResponse.user_code}**
+3. Authorize 'DollhouseMCP Collection'
+
+This will grant access to:
+✅ Browse the public collection
+✅ Install community content  
+✅ Submit your own creations
+
+Don't have a GitHub account? You'll be prompted to create one (it's free!)
+
+⏱️ This code expires in ${Math.floor(deviceResponse.expires_in / 60)} minutes.`;
+    }
+    /**
+     * Check if user needs to authenticate for a specific action
+     */
+    needsAuthForAction(action) {
+        const authRequiredActions = ['submit', 'create_pr', 'manage_content'];
+        return authRequiredActions.includes(action.toLowerCase());
+    }
+    /**
+     * Wait with abort signal support
+     */
+    async waitWithAbort(ms, signal) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(resolve, ms);
+            // Listen for abort signal
+            const abortHandler = () => {
+                clearTimeout(timeout);
+                reject(new Error('Wait aborted'));
+            };
+            signal.addEventListener('abort', abortHandler, { once: true });
+            // Clean up after timeout
+            setTimeout(() => {
+                signal.removeEventListener('abort', abortHandler);
+            }, ms);
+        });
+    }
+    /**
+     * Clean up any active operations (called on server shutdown)
+     */
+    async cleanup() {
+        // Abort any active polling
+        if (this.activePolling) {
+            this.activePolling.abort();
+            this.activePolling = null;
+            SecurityMonitor.logSecurityEvent({
+                type: 'TOKEN_CACHE_CLEARED',
+                severity: 'LOW',
+                source: 'GitHubAuthManager.cleanup',
+                details: 'GitHub auth manager cleaned up on shutdown',
+                metadata: {
+                    hadActivePolling: true
+                }
+            });
+            logger.info('GitHub authentication polling cancelled due to shutdown');
+        }
+        // Clear API cache
+        this.apiCache.clear();
+    }
+    /**
+     * Get user-friendly error message based on HTTP status code
+     * Avoids exposing sensitive information while providing helpful guidance
+     */
+    getErrorMessageForStatus(status, operation) {
+        switch (status) {
+            case 400:
+                return `Invalid request to GitHub. Please ensure the OAuth app is properly configured.`;
+            case 401:
+                return `Authentication failed. The OAuth app credentials may be invalid.`;
+            case 403:
+                return `Access denied by GitHub. The OAuth app may lack required permissions.`;
+            case 404:
+                return `GitHub service not found. This may indicate an API change.`;
+            case 422:
+                return `Invalid parameters sent to GitHub. Please check your configuration.`;
+            case 429:
+                return `Too many requests to GitHub. Please wait a moment and try again.`;
+            case 500:
+            case 502:
+            case 503:
+            case 504:
+                return `GitHub service temporarily unavailable. Please try again in a few moments.`;
+            default:
+                // Log the actual status for debugging, but don't expose it to users
+                logger.debug(`Unexpected status code during ${operation}`, { status });
+                return `Failed to complete ${operation}. Please check your internet connection and try again.`;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GitHubAuthManager.js","sourceRoot":"","sources":["../../src/auth/GitHubAuthManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAwBjE;;;GAGG;AACH,MAAM,OAAO,iBAAiB;IAC5B,8CAA8C;IAC9C,8CAA8C;IACtC,MAAM,CAAU,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC;IAE3E,yBAAyB;IACjB,MAAM,CAAU,eAAe,GAAG,sCAAsC,CAAC;IACzE,MAAM,CAAU,SAAS,GAAG,6CAA6C,CAAC;IAC1E,MAAM,CAAU,QAAQ,GAAG,6BAA6B,CAAC;IAEjE,wBAAwB;IAChB,MAAM,CAAU,qBAAqB,GAAG,IAAI,CAAC,CAAC,YAAY;IAC1D,MAAM,CAAU,iBAAiB,GAAG,GAAG,CAAC,CAAC,mBAAmB;IAE5D,QAAQ,CAAW;IACnB,aAAa,GAA2B,IAAI,CAAC;IAErD,YAAY,QAAkB;QAC5B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,cAAc,CAC1B,GAAW,EACX,OAAoB,EACpB,aAAqB,CAAC,EACtB,aAAqB,IAAI;QAEzB,IAAI,SAAS,GAAiB,IAAI,CAAC;QAEnC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC;YACvD,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;gBAC3C,OAAO,QAAQ,CAAC;YAClB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,SAAS,GAAG,KAAc,CAAC;gBAE3B,uDAAuD;gBACvD,MAAM,cAAc,GAAG,KAAK,YAAY,KAAK,IAAI,CAC/C,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;oBACtC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;oBACnC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;oBACnC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAClC,CAAC;gBAEF,IAAI,cAAc,IAAI,OAAO,GAAG,UAAU,EAAE,CAAC;oBAC3C,MAAM,CAAC,KAAK,CAAC,qCAAqC,OAAO,IAAI,UAAU,GAAG,EAAE;wBAC1E,GAAG;wBACH,KAAK,EAAE,KAAK,CAAC,OAAO;wBACpB,WAAW,EAAE,UAAU,GAAG,OAAO;qBAClC,CAAC,CAAC;oBAEH,sBAAsB;oBACtB,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC;gBAC1E,CAAC;qBAAM,CAAC;oBACN,yDAAyD;oBACzD,MAAM,KAAK,CAAC;gBACd,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,SAAS,IAAI,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAC3E,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,aAAa;QACjB,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,mBAAmB,EAAE,CAAC;QAEvD,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO;gBACL,eAAe,EAAE,KAAK;gBACtB,QAAQ,EAAE,KAAK;aAChB,CAAC;QACJ,CAAC;QAED,IAAI,CAAC;YACH,yCAAyC;YACzC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YAEjD,OAAO;gBACL,eAAe,EAAE,IAAI;gBACrB,QAAQ,EAAE,IAAI;gBACd,QAAQ,EAAE,QAAQ,CAAC,KAAK;gBACxB,MAAM,EAAE,QAAQ,CAAC,MAAM;aACxB,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,oCAAoC;YACpC,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YACnD,OAAO;gBACL,eAAe,EAAE,KAAK;gBACtB,QAAQ,EAAE,IAAI,CAAC,6BAA6B;aAC7C,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,kBAAkB;QACtB,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,8FAA8F;gBAC9F,uEAAuE,CACxE,CAAC;QACJ,CAAC;QAED,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,eAAe,EAAE;gBAC5E,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE;oBACP,QAAQ,EAAE,kBAAkB;oBAC5B,cAAc,EAAE,kBAAkB;iBACnC;gBACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;oBACnB,SAAS,EAAE,iBAAiB,CAAC,SAAS;oBACtC,KAAK,EAAE,uBAAuB;iBAC/B,CAAC;aACH,CAAC,CAAC;YAEH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,6DAA6D;gBAC7D,MAAM,YAAY,GAAG,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAC;gBAClG,MAAM,CAAC,KAAK,CAAC,+BAA+B,EAAE;oBAC5C,MAAM,EAAE,QAAQ,CAAC,MAAM;oBACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;iBAChC,CAAC,CAAC;gBACH,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC;YAChC,CAAC;YAED,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;YAEnC,oBAAoB;YACpB,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACnE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;YAC9D,CAAC;YAED,qCAAqC;YACrC,eAAe,CAAC,gBAAgB,CAAC;gBAC/B,IAAI,EAAE,0BAA0B;gBAChC,QAAQ,EAAE,KAAK;gBACf,MAAM,EAAE,sCAAsC;gBAC9C,OAAO,EAAE,oCAAoC;gBAC7C,QAAQ,EAAE;oBACR,QAAQ,EAAE,IAAI,CAAC,SAAS;oBACxB,SAAS,EAAE,IAAI,CAAC,UAAU;oBAC1B,QAAQ,EAAE,IAAI,CAAC,QAAQ;iBACxB;aACF,CAAC,CAAC;YAEH,OAAO,IAA0B,CAAC;QACpC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YAC1D,MAAM,IAAI,KAAK,CAAC,+EAA+E,CAAC,CAAC;QACnG,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY,CAAC,UAAkB,EAAE,WAAmB,iBAAiB,CAAC,qBAAqB;QAC/F,uDAAuD;QACvD,IAAI,CAAC,aAAa,GAAG,IAAI,eAAe,EAAE,CAAC;QAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;QAEzC,IAAI,QAAQ,GAAG,CAAC,CAAC;QAEjB,IAAI,CAAC;YACH,OAAO,QAAQ,GAAG,iBAAiB,CAAC,iBAAiB,EAAE,CAAC;gBACtD,+BAA+B;gBAC/B,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;gBAC1D,CAAC;gBAED,QAAQ,EAAE,CAAC;gBAEX,IAAI,CAAC;oBACL,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,iBAAiB,CAAC,SAAS,EAAE;wBACxD,MAAM,EAAE,MAAM;wBACd,OAAO,EAAE;4BACP,QAAQ,EAAE,kBAAkB;4BAC5B,cAAc,EAAE,kBAAkB;yBACnC;wBACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;4BACnB,SAAS,EAAE,iBAAiB,CAAC,SAAS;4BACtC,WAAW,EAAE,UAAU;4BACvB,UAAU,EAAE,8CAA8C;yBAC3D,CAAC;qBACH,CAAC,CAAC;oBAEH,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;oBAEnC,oCAAoC;oBACpC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;wBACf,QAAQ,IAAI,CAAC,KAAK,EAAE,CAAC;4BACnB,KAAK,uBAAuB;gCAC1B,2CAA2C;gCAC3C,MAAM;4BAER,KAAK,WAAW;gCACd,4BAA4B;gCAC5B,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,iBAAiB;gCAC7D,MAAM,CAAC,KAAK,CAAC,+BAA+B,EAAE,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,CAAC;gCACzE,MAAM;4BAER,KAAK,eAAe;gCAClB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;4BAE5E,KAAK,eAAe;gCAClB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;4BAEjE;gCACE,qCAAqC;gCACrC,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE;oCACtC,KAAK,EAAE,IAAI,CAAC,KAAK;oCACjB,WAAW,EAAE,IAAI,CAAC,iBAAiB;iCACpC,CAAC,CAAC;gCACH,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;wBACrF,CAAC;oBACH,CAAC;yBAAM,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;wBAC7B,WAAW;wBACX,OAAO,IAAqB,CAAC;oBAC/B,CAAC;oBAED,wBAAwB;oBACxB,uCAAuC;oBACvC,MAAM,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;gBAE7C,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,wCAAwC;oBACxC,MAAM,CAAC,KAAK,CAAC,qBAAqB,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;oBAClE,MAAM,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;gBAC7C,CAAC;YACH,CAAC;YAED,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QAC/D,CAAC;gBAAS,CAAC;YACT,iCAAiC;YACjC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,sBAAsB,CAAC,aAA4B;QACvD,uBAAuB;QACvB,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;QAElD,gBAAgB;QAChB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;QAEtE,2CAA2C;QAC3C,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,0BAA0B;YAChC,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,0CAA0C;YAClD,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE;gBACR,QAAQ,EAAE,QAAQ,CAAC,KAAK;gBACxB,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC;gBACtC,SAAS,EAAE,YAAY,CAAC,YAAY,CAAC,aAAa,CAAC,YAAY,CAAC;aACjE;SACF,CAAC,CAAC;QAEH,OAAO;YACL,eAAe,EAAE,IAAI;YACrB,QAAQ,EAAE,IAAI;YACd,QAAQ,EAAE,QAAQ,CAAC,KAAK;YACxB,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC;SACvC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,mBAAmB;QACvB,IAAI,CAAC;YACH,mCAAmC;YACnC,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,mBAAmB,EAAE,CAAC;YAEvD,IAAI,KAAK,EAAE,CAAC;gBACV,wCAAwC;gBACxC,oFAAoF;gBACpF,oDAAoD;gBAEpD,yBAAyB;gBACzB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;gBAEtB,qCAAqC;gBACrC,eAAe,CAAC,gBAAgB,CAAC;oBAC/B,IAAI,EAAE,qBAAqB;oBAC3B,QAAQ,EAAE,KAAK;oBACf,MAAM,EAAE,uCAAuC;oBAC/C,OAAO,EAAE,+CAA+C;oBACxD,QAAQ,EAAE;wBACR,QAAQ,EAAE,IAAI;wBACd,WAAW,EAAE,YAAY,CAAC,cAAc,CAAC,KAAK,CAAC;qBAChD;iBACF,CAAC,CAAC;YACL,CAAC;YAED,6BAA6B;YAC7B,MAAM,YAAY,CAAC,iBAAiB,EAAE,CAAC;YAEvC,MAAM,CAAC,IAAI,CAAC,4CAA4C,CAAC,CAAC;QAC5D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,+BAA+B,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YACzD,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,UAAU,CAAC,KAAa;QACpC,IAAI,CAAC;YACH,MAAM,YAAY,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;YAC3C,MAAM,CAAC,IAAI,CAAC,0DAA0D,CAAC,CAAC;QAC1E,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YAC1D,gDAAgD;YAChD,MAAM,CAAC,IAAI,CAAC,kEAAkE,CAAC,CAAC;YAChF,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,aAAa,CAAC,KAAa;QACvC,oBAAoB;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAC7D,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,QAAQ,EAAE;YACrE,OAAO,EAAE;gBACP,eAAe,EAAE,UAAU,KAAK,EAAE;gBAClC,QAAQ,EAAE,gCAAgC;aAC3C;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,MAAM,YAAY,GAAG,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;YAC9F,MAAM,CAAC,KAAK,CAAC,2BAA2B,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;YACvE,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC;QAChC,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QAEnC,sEAAsE;QACtE,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,MAAM,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC1D,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;gBACxB,eAAe,CAAC,gBAAgB,CAAC;oBAC/B,IAAI,EAAE,0BAA0B;oBAChC,QAAQ,EAAE,QAAQ;oBAClB,MAAM,EAAE,iCAAiC;oBACzC,OAAO,EAAE,0CAA0C;oBACnD,QAAQ,EAAE;wBACR,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM;wBACjC,cAAc,EAAE,UAAU,CAAC,cAAc;qBAC1C;iBACF,CAAC,CAAC;gBACH,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;YACzD,CAAC;YACD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,iBAAiB,CAAC;QAC5C,CAAC;QAED,oCAAoC;QACpC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,MAAM,cAAc,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7D,IAAI,cAAc,CAAC,OAAO,EAAE,CAAC;gBAC3B,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC,iBAAiB,CAAC;YAC/C,CAAC;iBAAM,CAAC;gBACN,6CAA6C;gBAC7C,OAAO,IAAI,CAAC,IAAI,CAAC;YACnB,CAAC;QACH,CAAC;QAED,mCAAmC;QACnC,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAC3D,IAAI,WAAW,EAAE,CAAC;YAChB,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1D,CAAC;QAED,gDAAgD;QAChD,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,0BAA0B;YAChC,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,iCAAiC;YACzC,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE;gBACR,QAAQ,EAAE,IAAI,CAAC,KAAK;gBACpB,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK;gBACtB,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,EAAE;aAC1B;SACF,CAAC,CAAC;QAEH,mBAAmB;QACnB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,iBAAiB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAEpD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,sBAAsB,CAAC,cAAkC;QACvD,OAAO;;;;cAIG,cAAc,CAAC,gBAAgB;mBAC1B,cAAc,CAAC,SAAS;;;;;;;;;;0BAUjB,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,GAAG,EAAE,CAAC,WAAW,CAAC;IAC9E,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,MAAc;QAC/B,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;QACtE,OAAO,mBAAmB,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,aAAa,CAAC,EAAU,EAAE,MAAmB;QACzD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YAExC,0BAA0B;YAC1B,MAAM,YAAY,GAAG,GAAG,EAAE;gBACxB,YAAY,CAAC,OAAO,CAAC,CAAC;gBACtB,MAAM,CAAC,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;YACpC,CAAC,CAAC;YAEF,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YAE/D,yBAAyB;YACzB,UAAU,CAAC,GAAG,EAAE;gBACd,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;YACpD,CAAC,EAAE,EAAE,CAAC,CAAC;QACT,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO;QACX,2BAA2B;QAC3B,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YAC3B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAE1B,eAAe,CAAC,gBAAgB,CAAC;gBAC/B,IAAI,EAAE,qBAAqB;gBAC3B,QAAQ,EAAE,KAAK;gBACf,MAAM,EAAE,2BAA2B;gBACnC,OAAO,EAAE,4CAA4C;gBACrD,QAAQ,EAAE;oBACR,gBAAgB,EAAE,IAAI;iBACvB;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;QACzE,CAAC;QAED,kBAAkB;QAClB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;IAED;;;OAGG;IACK,wBAAwB,CAAC,MAAc,EAAE,SAAiB;QAChE,QAAQ,MAAM,EAAE,CAAC;YACf,KAAK,GAAG;gBACN,OAAO,gFAAgF,CAAC;YAC1F,KAAK,GAAG;gBACN,OAAO,kEAAkE,CAAC;YAC5E,KAAK,GAAG;gBACN,OAAO,uEAAuE,CAAC;YACjF,KAAK,GAAG;gBACN,OAAO,4DAA4D,CAAC;YACtE,KAAK,GAAG;gBACN,OAAO,qEAAqE,CAAC;YAC/E,KAAK,GAAG;gBACN,OAAO,kEAAkE,CAAC;YAC5E,KAAK,GAAG,CAAC;YACT,KAAK,GAAG,CAAC;YACT,KAAK,GAAG,CAAC;YACT,KAAK,GAAG;gBACN,OAAO,4EAA4E,CAAC;YACtF;gBACE,oEAAoE;gBACpE,MAAM,CAAC,KAAK,CAAC,iCAAiC,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;gBACvE,OAAO,sBAAsB,SAAS,wDAAwD,CAAC;QACnG,CAAC;IACH,CAAC","sourcesContent":["/**\n * GitHub authentication manager using OAuth device flow\n * Handles authentication for MCP servers without requiring client secrets\n */\n\nimport { TokenManager } from '../security/tokenManager.js';\nimport { logger } from '../utils/logger.js';\nimport { APICache } from '../cache/APICache.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\nexport interface DeviceCodeResponse {\n  device_code: string;\n  user_code: string;\n  verification_uri: string;\n  expires_in: number;\n  interval: number;\n}\n\nexport interface TokenResponse {\n  access_token: string;\n  token_type: string;\n  scope: string;\n}\n\nexport interface AuthStatus {\n  isAuthenticated: boolean;\n  hasToken: boolean;\n  username?: string;\n  scopes?: string[];\n  expiresAt?: Date;\n}\n\n/**\n * Manages GitHub authentication using the OAuth device flow\n * This is the recommended approach for CLI/desktop applications\n */\nexport class GitHubAuthManager {\n  // GitHub OAuth App Client ID for DollhouseMCP\n  // Must be configured via environment variable\n  private static readonly CLIENT_ID = process.env.DOLLHOUSE_GITHUB_CLIENT_ID;\n  \n  // GitHub OAuth endpoints\n  private static readonly DEVICE_CODE_URL = 'https://github.com/login/device/code';\n  private static readonly TOKEN_URL = 'https://github.com/login/oauth/access_token';\n  private static readonly USER_URL = 'https://api.github.com/user';\n  \n  // Polling configuration\n  private static readonly DEFAULT_POLL_INTERVAL = 5000; // 5 seconds\n  private static readonly MAX_POLL_ATTEMPTS = 180; // 15 minutes total\n  \n  private apiCache: APICache;\n  private activePolling: AbortController | null = null;\n  \n  constructor(apiCache: APICache) {\n    this.apiCache = apiCache;\n  }\n  \n  /**\n   * Execute a network request with retry logic\n   */\n  private async fetchWithRetry(\n    url: string, \n    options: RequestInit, \n    maxRetries: number = 3,\n    retryDelay: number = 1000\n  ): Promise<Response> {\n    let lastError: Error | null = null;\n    \n    for (let attempt = 1; attempt <= maxRetries; attempt++) {\n      try {\n        const response = await fetch(url, options);\n        return response;\n      } catch (error) {\n        lastError = error as Error;\n        \n        // Check if it's a network error that should be retried\n        const isNetworkError = error instanceof Error && (\n          error.message.includes('ECONNREFUSED') ||\n          error.message.includes('ETIMEDOUT') ||\n          error.message.includes('ENOTFOUND') ||\n          error.message.includes('network')\n        );\n        \n        if (isNetworkError && attempt < maxRetries) {\n          logger.debug(`Network request failed, retrying (${attempt}/${maxRetries})`, {\n            url,\n            error: error.message,\n            nextRetryIn: retryDelay * attempt\n          });\n          \n          // Exponential backoff\n          await new Promise(resolve => setTimeout(resolve, retryDelay * attempt));\n        } else {\n          // Not a network error or last attempt, throw immediately\n          throw error;\n        }\n      }\n    }\n    \n    throw lastError || new Error('Network request failed after all retries');\n  }\n  \n  /**\n   * Check current authentication status\n   */\n  async getAuthStatus(): Promise<AuthStatus> {\n    const token = await TokenManager.getGitHubTokenAsync();\n    \n    if (!token) {\n      return {\n        isAuthenticated: false,\n        hasToken: false\n      };\n    }\n    \n    try {\n      // Try to get user info to validate token\n      const userInfo = await this.fetchUserInfo(token);\n      \n      return {\n        isAuthenticated: true,\n        hasToken: true,\n        username: userInfo.login,\n        scopes: userInfo.scopes\n      };\n    } catch (error) {\n      // Token might be invalid or expired\n      logger.debug('Token validation failed', { error });\n      return {\n        isAuthenticated: false,\n        hasToken: true // Has token but it's invalid\n      };\n    }\n  }\n  \n  /**\n   * Initiate the device flow authentication process\n   */\n  async initiateDeviceFlow(): Promise<DeviceCodeResponse> {\n    if (!GitHubAuthManager.CLIENT_ID) {\n      throw new Error(\n        'GitHub OAuth is not configured. Please set DOLLHOUSE_GITHUB_CLIENT_ID environment variable. ' +\n        'Register an OAuth app at https://github.com/settings/applications/new'\n      );\n    }\n    \n    try {\n      const response = await this.fetchWithRetry(GitHubAuthManager.DEVICE_CODE_URL, {\n        method: 'POST',\n        headers: {\n          'Accept': 'application/json',\n          'Content-Type': 'application/json'\n        },\n        body: JSON.stringify({\n          client_id: GitHubAuthManager.CLIENT_ID,\n          scope: 'public_repo read:user'\n        })\n      });\n      \n      if (!response.ok) {\n        // Provide user-friendly error messages based on status codes\n        const errorMessage = this.getErrorMessageForStatus(response.status, 'device flow initialization');\n        logger.debug('Device flow initiation failed', { \n          status: response.status, \n          statusText: response.statusText \n        });\n        throw new Error(errorMessage);\n      }\n      \n      const data = await response.json();\n      \n      // Validate response\n      if (!data.device_code || !data.user_code || !data.verification_uri) {\n        throw new Error('Invalid device flow response from GitHub');\n      }\n      \n      // Log security event for audit trail\n      SecurityMonitor.logSecurityEvent({\n        type: 'TOKEN_VALIDATION_SUCCESS',\n        severity: 'LOW',\n        source: 'GitHubAuthManager.initiateDeviceFlow',\n        details: 'GitHub OAuth device flow initiated',\n        metadata: {\n          userCode: data.user_code,\n          expiresIn: data.expires_in,\n          interval: data.interval\n        }\n      });\n      \n      return data as DeviceCodeResponse;\n    } catch (error) {\n      logger.error('Failed to initiate device flow', { error });\n      throw new Error('Failed to start GitHub authentication. Please check your internet connection.');\n    }\n  }\n  \n  /**\n   * Poll for token after user has authorized the device\n   */\n  async pollForToken(deviceCode: string, interval: number = GitHubAuthManager.DEFAULT_POLL_INTERVAL): Promise<TokenResponse> {\n    // Create new abort controller for this polling session\n    this.activePolling = new AbortController();\n    const signal = this.activePolling.signal;\n    \n    let attempts = 0;\n    \n    try {\n      while (attempts < GitHubAuthManager.MAX_POLL_ATTEMPTS) {\n        // Check if polling was aborted\n        if (signal.aborted) {\n          throw new Error('Authentication polling was cancelled');\n        }\n        \n        attempts++;\n        \n        try {\n        const response = await fetch(GitHubAuthManager.TOKEN_URL, {\n          method: 'POST',\n          headers: {\n            'Accept': 'application/json',\n            'Content-Type': 'application/json'\n          },\n          body: JSON.stringify({\n            client_id: GitHubAuthManager.CLIENT_ID,\n            device_code: deviceCode,\n            grant_type: 'urn:ietf:params:oauth:grant-type:device_code'\n          })\n        });\n        \n        const data = await response.json();\n        \n        // Check for various response states\n        if (data.error) {\n          switch (data.error) {\n            case 'authorization_pending':\n              // User hasn't authorized yet, keep polling\n              break;\n              \n            case 'slow_down':\n              // Increase polling interval\n              interval = Math.min(interval * 1.5, 30000); // Max 30 seconds\n              logger.debug('Slowing down polling interval', { newInterval: interval });\n              break;\n              \n            case 'expired_token':\n              throw new Error('The authorization code has expired. Please start over.');\n              \n            case 'access_denied':\n              throw new Error('Authorization was denied. Please try again.');\n              \n            default:\n              // Log the actual error for debugging\n              logger.debug('OAuth device flow error', { \n                error: data.error, \n                description: data.error_description \n              });\n              throw new Error('Authentication failed. Please try starting the process again.');\n          }\n        } else if (data.access_token) {\n          // Success!\n          return data as TokenResponse;\n        }\n        \n        // Wait before next poll\n        // Wait for interval with abort support\n        await this.waitWithAbort(interval, signal);\n        \n      } catch (error) {\n        // Network errors shouldn't stop polling\n        logger.debug('Poll attempt failed', { attempt: attempts, error });\n        await this.waitWithAbort(interval, signal);\n      }\n    }\n    \n    throw new Error('Authentication timed out. Please try again.');\n    } finally {\n      // Clear active polling reference\n      this.activePolling = null;\n    }\n  }\n  \n  /**\n   * Complete the authentication flow and store the token\n   */\n  async completeAuthentication(tokenResponse: TokenResponse): Promise<AuthStatus> {\n    // Store token securely\n    await this.storeToken(tokenResponse.access_token);\n    \n    // Get user info\n    const userInfo = await this.fetchUserInfo(tokenResponse.access_token);\n    \n    // Log successful authentication completion\n    SecurityMonitor.logSecurityEvent({\n      type: 'TOKEN_VALIDATION_SUCCESS',\n      severity: 'LOW',\n      source: 'GitHubAuthManager.completeAuthentication',\n      details: 'GitHub OAuth device flow completed successfully',\n      metadata: {\n        username: userInfo.login,\n        scopes: tokenResponse.scope.split(' '),\n        tokenType: TokenManager.getTokenType(tokenResponse.access_token)\n      }\n    });\n    \n    return {\n      isAuthenticated: true,\n      hasToken: true,\n      username: userInfo.login,\n      scopes: tokenResponse.scope.split(' ')\n    };\n  }\n  \n  /**\n   * Clear stored authentication and revoke token\n   */\n  async clearAuthentication(): Promise<void> {\n    try {\n      // Get the token before clearing it\n      const token = await TokenManager.getGitHubTokenAsync();\n      \n      if (token) {\n        // Attempt to revoke the token on GitHub\n        // Note: GitHub OAuth tokens don't have a revocation endpoint for device flow tokens\n        // But we'll clear the cache and remove from storage\n        \n        // Clear cached user info\n        this.apiCache.clear();\n        \n        // Log security event for audit trail\n        SecurityMonitor.logSecurityEvent({\n          type: 'TOKEN_CACHE_CLEARED',\n          severity: 'LOW',\n          source: 'GitHubAuthManager.clearAuthentication',\n          details: 'GitHub authentication cleared by user request',\n          metadata: {\n            hadToken: true,\n            tokenPrefix: TokenManager.getTokenPrefix(token)\n          }\n        });\n      }\n      \n      // Remove from secure storage\n      await TokenManager.removeStoredToken();\n      \n      logger.info('GitHub authentication cleared successfully');\n    } catch (error) {\n      logger.error('Error clearing authentication', { error });\n      throw new Error('Failed to clear authentication');\n    }\n  }\n  \n  /**\n   * Store token securely using encrypted file storage\n   */\n  private async storeToken(token: string): Promise<void> {\n    try {\n      await TokenManager.storeGitHubToken(token);\n      logger.info('GitHub token stored securely. You are now authenticated!');\n    } catch (error) {\n      logger.error('Failed to store token securely', { error });\n      // Fallback to environment variable instructions\n      logger.info('For manual setup, you can set GITHUB_TOKEN environment variable.');\n      throw error;\n    }\n  }\n  \n  /**\n   * Fetch user information from GitHub\n   */\n  private async fetchUserInfo(token: string): Promise<any> {\n    // Check cache first\n    const cached = this.apiCache.get(GitHubAuthManager.USER_URL);\n    if (cached) {\n      return cached;\n    }\n    \n    const response = await this.fetchWithRetry(GitHubAuthManager.USER_URL, {\n      headers: {\n        'Authorization': `Bearer ${token}`,\n        'Accept': 'application/vnd.github.v3+json'\n      }\n    });\n    \n    if (!response.ok) {\n      const errorMessage = this.getErrorMessageForStatus(response.status, 'user information fetch');\n      logger.debug('Failed to fetch user info', { status: response.status });\n      throw new Error(errorMessage);\n    }\n    \n    const data = await response.json();\n    \n    // Normalize username and other text fields to prevent Unicode attacks\n    if (data.login) {\n      const validation = UnicodeValidator.normalize(data.login);\n      if (!validation.isValid) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'UNICODE_VALIDATION_ERROR',\n          severity: 'MEDIUM',\n          source: 'GitHubAuthManager.fetchUserInfo',\n          details: 'GitHub username contains invalid Unicode',\n          metadata: { \n            originalLength: data.login.length,\n            detectedIssues: validation.detectedIssues \n          }\n        });\n        throw new Error('Invalid username format from GitHub');\n      }\n      data.login = validation.normalizedContent;\n    }\n    \n    // Normalize display name if present\n    if (data.name) {\n      const nameValidation = UnicodeValidator.normalize(data.name);\n      if (nameValidation.isValid) {\n        data.name = nameValidation.normalizedContent;\n      } else {\n        // Don't fail on display name, just remove it\n        delete data.name;\n      }\n    }\n    \n    // Add scopes from response headers\n    const scopeHeader = response.headers.get('x-oauth-scopes');\n    if (scopeHeader) {\n      data.scopes = scopeHeader.split(',').map(s => s.trim());\n    }\n    \n    // Log successful authentication for audit trail\n    SecurityMonitor.logSecurityEvent({\n      type: 'TOKEN_VALIDATION_SUCCESS',\n      severity: 'LOW',\n      source: 'GitHubAuthManager.fetchUserInfo',\n      details: 'GitHub user authenticated successfully',\n      metadata: {\n        username: data.login,\n        hasEmail: !!data.email,\n        scopes: data.scopes || []\n      }\n    });\n    \n    // Cache the result\n    this.apiCache.set(GitHubAuthManager.USER_URL, data);\n    \n    return data;\n  }\n  \n  /**\n   * Format authentication instructions for users\n   */\n  formatAuthInstructions(deviceResponse: DeviceCodeResponse): string {\n    return `🔐 **GitHub Authentication Required**\n\nTo access all DollhouseMCP features, please authenticate with GitHub:\n\n1. Visit: **${deviceResponse.verification_uri}**\n2. Enter code: **${deviceResponse.user_code}**\n3. Authorize 'DollhouseMCP Collection'\n\nThis will grant access to:\n✅ Browse the public collection\n✅ Install community content  \n✅ Submit your own creations\n\nDon't have a GitHub account? You'll be prompted to create one (it's free!)\n\n⏱️ This code expires in ${Math.floor(deviceResponse.expires_in / 60)} minutes.`;\n  }\n  \n  /**\n   * Check if user needs to authenticate for a specific action\n   */\n  needsAuthForAction(action: string): boolean {\n    const authRequiredActions = ['submit', 'create_pr', 'manage_content'];\n    return authRequiredActions.includes(action.toLowerCase());\n  }\n  \n  /**\n   * Wait with abort signal support\n   */\n  private async waitWithAbort(ms: number, signal: AbortSignal): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const timeout = setTimeout(resolve, ms);\n      \n      // Listen for abort signal\n      const abortHandler = () => {\n        clearTimeout(timeout);\n        reject(new Error('Wait aborted'));\n      };\n      \n      signal.addEventListener('abort', abortHandler, { once: true });\n      \n      // Clean up after timeout\n      setTimeout(() => {\n        signal.removeEventListener('abort', abortHandler);\n      }, ms);\n    });\n  }\n  \n  /**\n   * Clean up any active operations (called on server shutdown)\n   */\n  async cleanup(): Promise<void> {\n    // Abort any active polling\n    if (this.activePolling) {\n      this.activePolling.abort();\n      this.activePolling = null;\n      \n      SecurityMonitor.logSecurityEvent({\n        type: 'TOKEN_CACHE_CLEARED',\n        severity: 'LOW',\n        source: 'GitHubAuthManager.cleanup',\n        details: 'GitHub auth manager cleaned up on shutdown',\n        metadata: {\n          hadActivePolling: true\n        }\n      });\n      \n      logger.info('GitHub authentication polling cancelled due to shutdown');\n    }\n    \n    // Clear API cache\n    this.apiCache.clear();\n  }\n  \n  /**\n   * Get user-friendly error message based on HTTP status code\n   * Avoids exposing sensitive information while providing helpful guidance\n   */\n  private getErrorMessageForStatus(status: number, operation: string): string {\n    switch (status) {\n      case 400:\n        return `Invalid request to GitHub. Please ensure the OAuth app is properly configured.`;\n      case 401:\n        return `Authentication failed. The OAuth app credentials may be invalid.`;\n      case 403:\n        return `Access denied by GitHub. The OAuth app may lack required permissions.`;\n      case 404:\n        return `GitHub service not found. This may indicate an API change.`;\n      case 422:\n        return `Invalid parameters sent to GitHub. Please check your configuration.`;\n      case 429:\n        return `Too many requests to GitHub. Please wait a moment and try again.`;\n      case 500:\n      case 502:\n      case 503:\n      case 504:\n        return `GitHub service temporarily unavailable. Please try again in a few moments.`;\n      default:\n        // Log the actual status for debugging, but don't expose it to users\n        logger.debug(`Unexpected status code during ${operation}`, { status });\n        return `Failed to complete ${operation}. Please check your internet connection and try again.`;\n    }\n  }\n}"]}

package/dist/generated/version.d.ts

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export declare const PACKAGE_VERSION = "1.4.4";
-export declare const BUILD_TIMESTAMP = "2025-08-04T22:59:30.004Z";
+export declare const PACKAGE_VERSION = "1.5.0";
+export declare const BUILD_TIMESTAMP = "2025-08-05T17:55:53.994Z";
 export declare const BUILD_TYPE: 'npm' | 'git';
 export declare const PACKAGE_NAME = "@dollhousemcp/mcp-server";
 //# sourceMappingURL=version.d.ts.map

package/dist/generated/version.js

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export const PACKAGE_VERSION = '1.4.4';
-export const BUILD_TIMESTAMP = '2025-08-04T22:59:30.004Z';
+export const PACKAGE_VERSION = '1.5.0';
+export const BUILD_TIMESTAMP = '2025-08-05T17:55:53.994Z';
 export const BUILD_TYPE = 'npm';
 export const PACKAGE_NAME = '@dollhousemcp/mcp-server';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDO0FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcxLjQuNCc7XG5leHBvcnQgY29uc3QgQlVJTERfVElNRVNUQU1QID0gJzIwMjUtMDgtMDRUMjI6NTk6MzAuMDA0Wic7XG5leHBvcnQgY29uc3QgQlVJTERfVFlQRTogJ25wbScgfCAnZ2l0JyA9ICducG0nO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfTkFNRSA9ICdAZG9sbGhvdXNlbWNwL21jcC1zZXJ2ZXInO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDO0FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcxLjUuMCc7XG5leHBvcnQgY29uc3QgQlVJTERfVElNRVNUQU1QID0gJzIwMjUtMDgtMDVUMTc6NTU6NTMuOTk0Wic7XG5leHBvcnQgY29uc3QgQlVJTERfVFlQRTogJ25wbScgfCAnZ2l0JyA9ICducG0nO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfTkFNRSA9ICdAZG9sbGhvdXNlbWNwL21jcC1zZXJ2ZXInO1xuIl19

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export declare class DollhouseMCPServer implements IToolHandler {
     private rateLimitTracker;
     private indicatorConfig;
     private githubClient;
+    private githubAuthManager;
     private collectionBrowser;
     private collectionSearch;
     private personaDetails;
@@ -216,6 +217,28 @@ export declare class DollhouseMCPServer implements IToolHandler {
         }[];
     }>;
     private getCurrentUserForAttribution;
+    setupGitHubAuth(): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    checkGitHubAuth(): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    clearGitHubAuth(): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    /**
+     * Poll for auth completion in the background
+     */
+    private pollForAuthCompletion;
     createPersona(name: string, description: string, category: string, instructions: string, triggers?: string): Promise<{
         content: {
             type: string;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}