@taazkareem/clickup-mcp-server 0.8.5 → 0.9.1

package/build/services/auth/oauth2.js

@@ -0,0 +1,236 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * OAuth2 Authentication Service
+ *
+ * Handles OAuth2 authentication flow with ClickUp API:
+ * - Authorization URL generation
+ * - Token exchange and refresh
+ * - User information retrieval
+ * - Token validation and management
+ */
+import axios from 'axios';
+import { Logger } from '../../logger.js';
+/**
+ * OAuth2 service for ClickUp authentication
+ */
+export class OAuth2Service {
+    constructor(config) {
+        this.config = {
+            baseUrl: 'https://api.clickup.com/api/v2',
+            scopes: ['read', 'write'],
+            ...config
+        };
+        this.logger = new Logger('OAuth2Service');
+        // Create HTTP client for OAuth2 operations
+        this.client = axios.create({
+            baseURL: this.config.baseUrl,
+            timeout: 30000,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        this.logger.info('OAuth2 service initialized', {
+            clientId: this.config.clientId,
+            redirectUri: this.config.redirectUri,
+            scopes: this.config.scopes
+        });
+    }
+    /**
+     * Generate OAuth2 authorization URL
+     * @param state Optional state parameter for CSRF protection
+     * @returns Authorization URL for user redirection
+     */
+    generateAuthorizationUrl(state) {
+        const params = new URLSearchParams({
+            client_id: this.config.clientId,
+            redirect_uri: this.config.redirectUri,
+            response_type: 'code',
+            scope: this.config.scopes?.join(' ') || 'read write'
+        });
+        if (state) {
+            params.append('state', state);
+        }
+        const authUrl = `https://app.clickup.com/api?${params.toString()}`;
+        this.logger.info('Generated authorization URL', {
+            clientId: this.config.clientId,
+            redirectUri: this.config.redirectUri,
+            state: state || 'none'
+        });
+        return authUrl;
+    }
+    /**
+     * Exchange authorization code for access token
+     * @param code Authorization code from ClickUp callback
+     * @returns OAuth2 authentication result with tokens and user info
+     */
+    async exchangeCodeForToken(code) {
+        try {
+            this.logger.info('Exchanging authorization code for token', { code: code.substring(0, 10) + '...' });
+            // Exchange code for token
+            const tokenResponse = await this.client.post('/oauth/token', {
+                client_id: this.config.clientId,
+                client_secret: this.config.clientSecret,
+                code: code,
+                redirect_uri: this.config.redirectUri,
+                grant_type: 'authorization_code'
+            });
+            const tokens = tokenResponse.data;
+            this.logger.info('Successfully exchanged code for token', {
+                tokenType: tokens.token_type,
+                expiresIn: tokens.expires_in,
+                hasRefreshToken: !!tokens.refresh_token
+            });
+            // Get user information using the access token
+            const userInfo = await this.getUserInfo(tokens.access_token);
+            if (!userInfo.success || !userInfo.user) {
+                return {
+                    success: false,
+                    error: {
+                        message: 'Failed to retrieve user information',
+                        details: userInfo.error
+                    }
+                };
+            }
+            return {
+                success: true,
+                tokens,
+                user: userInfo.user
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to exchange code for token', {
+                error: error.message,
+                status: error.response?.status,
+                data: error.response?.data
+            });
+            return {
+                success: false,
+                error: {
+                    message: 'OAuth2 token exchange failed',
+                    code: 'TOKEN_EXCHANGE_FAILED',
+                    details: error.response?.data || error.message
+                }
+            };
+        }
+    }
+    /**
+     * Refresh access token using refresh token
+     * @param refreshToken Refresh token from previous authentication
+     * @returns New token response or error
+     */
+    async refreshToken(refreshToken) {
+        try {
+            this.logger.info('Refreshing access token');
+            const response = await this.client.post('/oauth/token', {
+                client_id: this.config.clientId,
+                client_secret: this.config.clientSecret,
+                refresh_token: refreshToken,
+                grant_type: 'refresh_token'
+            });
+            const tokens = response.data;
+            this.logger.info('Successfully refreshed token', {
+                tokenType: tokens.token_type,
+                expiresIn: tokens.expires_in
+            });
+            return {
+                success: true,
+                tokens
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to refresh token', {
+                error: error.message,
+                status: error.response?.status
+            });
+            return {
+                success: false,
+                error: {
+                    message: 'Token refresh failed',
+                    code: 'TOKEN_REFRESH_FAILED',
+                    details: error.response?.data || error.message
+                }
+            };
+        }
+    }
+    /**
+     * Get user information using access token
+     * @param accessToken Valid access token
+     * @returns User information or error
+     */
+    async getUserInfo(accessToken) {
+        try {
+            this.logger.info('Retrieving user information');
+            const response = await this.client.get('/user', {
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`
+                }
+            });
+            const userData = response.data;
+            const user = userData.user || userData;
+            this.logger.info('Successfully retrieved user information', {
+                userId: user.id,
+                username: user.username,
+                email: user.email
+            });
+            return {
+                success: true,
+                user
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to retrieve user information', {
+                error: error.message,
+                status: error.response?.status
+            });
+            return {
+                success: false,
+                error: {
+                    message: 'Failed to retrieve user information',
+                    code: 'USER_INFO_FAILED',
+                    details: error.response?.data || error.message
+                }
+            };
+        }
+    }
+    /**
+     * Validate access token by making a test API call
+     * @param accessToken Token to validate
+     * @returns Whether the token is valid
+     */
+    async validateToken(accessToken) {
+        try {
+            const result = await this.getUserInfo(accessToken);
+            return result.success;
+        }
+        catch (error) {
+            this.logger.warn('Token validation failed', { error });
+            return false;
+        }
+    }
+    /**
+     * Revoke access token
+     * @param accessToken Token to revoke
+     * @returns Success status
+     */
+    async revokeToken(accessToken) {
+        try {
+            this.logger.info('Revoking access token');
+            await this.client.post('/oauth/revoke', {
+                token: accessToken,
+                client_id: this.config.clientId,
+                client_secret: this.config.clientSecret
+            });
+            this.logger.info('Successfully revoked token');
+            return true;
+        }
+        catch (error) {
+            this.logger.error('Failed to revoke token', {
+                error: error.message,
+                status: error.response?.status
+            });
+            return false;
+        }
+    }
+}

package/build/services/auth/session.js

@@ -0,0 +1,337 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * Simple Session Management Service
+ *
+ * Handles user session management for OAuth2 authentication:
+ * - In-memory session storage with TTL
+ * - Token management and refresh
+ * - Session validation and cleanup
+ * - Automatic expiration handling
+ */
+import { Logger } from '../../logger.js';
+/**
+ * Simple in-memory session management service
+ */
+export class SessionService {
+    constructor() {
+        this.sessions = new Map();
+        this.logger = new Logger('SessionService');
+        this.logger.info('Simple session service initialized (in-memory)');
+        // Start cleanup interval (every 10 minutes)
+        this.cleanupInterval = setInterval(() => this.cleanupExpiredSessions(), 10 * 60 * 1000);
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+        this.sessions.clear();
+        this.logger.info('Session service destroyed');
+    }
+    /**
+     * Create a new user session
+     * @param sessionData Session creation data
+     * @returns Created session or error
+     */
+    async createSession(sessionData) {
+        try {
+            this.logger.info('Creating new session', {
+                clickupUserId: sessionData.clickupUserId,
+                tokenType: sessionData.tokens.token_type
+            });
+            // Generate unique session ID
+            const sessionId = this.generateSessionId();
+            // Calculate expiration time
+            const expiresAt = new Date(Date.now() + (sessionData.tokens.expires_in * 1000));
+            const now = new Date();
+            // Create session object
+            const session = {
+                id: sessionId,
+                clickupUserId: sessionData.clickupUserId,
+                accessToken: sessionData.tokens.access_token,
+                refreshToken: sessionData.tokens.refresh_token,
+                tokenType: sessionData.tokens.token_type,
+                expiresAt,
+                createdAt: now,
+                lastAccessedAt: now
+            };
+            // Store in memory
+            this.sessions.set(sessionId, session);
+            this.logger.info('Session created successfully', {
+                sessionId: session.id,
+                clickupUserId: sessionData.clickupUserId,
+                expiresAt: session.expiresAt.toISOString()
+            });
+            return {
+                success: true,
+                data: session
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create session', {
+                error: error.message,
+                sessionData
+            });
+            return {
+                success: false,
+                error: {
+                    message: 'Failed to create session',
+                    code: 'SESSION_CREATION_FAILED',
+                    details: error.message
+                }
+            };
+        }
+    }
+    /**
+     * Get session by ID
+     * @param sessionId Session ID
+     * @returns Session or null if not found/expired
+     */
+    async getSession(sessionId) {
+        try {
+            this.logger.debug('Getting session', { sessionId });
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                return {
+                    success: true,
+                    data: null
+                };
+            }
+            // Check if session is expired
+            if (session.expiresAt <= new Date()) {
+                this.logger.debug('Session expired, removing', { sessionId });
+                this.sessions.delete(sessionId);
+                return {
+                    success: true,
+                    data: null
+                };
+            }
+            // Update last accessed time
+            session.lastAccessedAt = new Date();
+            return {
+                success: true,
+                data: session
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get session', {
+                error: error.message,
+                sessionId
+            });
+            return {
+                success: false,
+                error: {
+                    message: 'Failed to get session',
+                    code: 'SESSION_RETRIEVAL_FAILED',
+                    details: error.message
+                }
+            };
+        }
+    }
+    /**
+     * Update session tokens (after refresh)
+     * @param sessionId Session ID
+     * @param tokens New token data
+     * @returns Updated session or error
+     */
+    async updateSessionTokens(sessionId, tokens) {
+        try {
+            this.logger.info('Updating session tokens', { sessionId });
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                return {
+                    success: false,
+                    error: {
+                        message: 'Session not found',
+                        code: 'SESSION_NOT_FOUND'
+                    }
+                };
+            }
+            // Update session with new tokens
+            session.accessToken = tokens.access_token;
+            if (tokens.refresh_token) {
+                session.refreshToken = tokens.refresh_token;
+            }
+            session.tokenType = tokens.token_type;
+            session.expiresAt = new Date(Date.now() + (tokens.expires_in * 1000));
+            session.lastAccessedAt = new Date();
+            this.logger.info('Session tokens updated successfully', {
+                sessionId,
+                newExpiresAt: session.expiresAt.toISOString()
+            });
+            return {
+                success: true,
+                data: session
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to update session tokens', {
+                error: error.message,
+                sessionId
+            });
+            return {
+                success: false,
+                error: {
+                    message: 'Failed to update session tokens',
+                    code: 'SESSION_UPDATE_FAILED',
+                    details: error.message
+                }
+            };
+        }
+    }
+    /**
+     * Delete session
+     * @param sessionId Session ID
+     * @returns Success status
+     */
+    async deleteSession(sessionId) {
+        try {
+            this.logger.info('Deleting session', { sessionId });
+            const deleted = this.sessions.delete(sessionId);
+            this.logger.info('Session deleted successfully', { sessionId, deleted });
+            return {
+                success: true,
+                data: deleted
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to delete session', {
+                error: error.message,
+                sessionId
+            });
+            return {
+                success: false,
+                error: {
+                    message: 'Failed to delete session',
+                    code: 'SESSION_DELETION_FAILED',
+                    details: error.message
+                }
+            };
+        }
+    }
+    /**
+     * Delete all sessions for a user
+     * @param clickupUserId ClickUp user ID
+     * @returns Success status
+     */
+    async deleteUserSessions(clickupUserId) {
+        try {
+            this.logger.info('Deleting all sessions for user', { clickupUserId });
+            let deletedCount = 0;
+            for (const [sessionId, session] of this.sessions.entries()) {
+                if (session.clickupUserId === clickupUserId) {
+                    this.sessions.delete(sessionId);
+                    deletedCount++;
+                }
+            }
+            this.logger.info('All user sessions deleted successfully', {
+                clickupUserId,
+                deletedCount
+            });
+            return {
+                success: true,
+                data: true
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to delete user sessions', {
+                error: error.message,
+                clickupUserId
+            });
+            return {
+                success: false,
+                error: {
+                    message: 'Failed to delete user sessions',
+                    code: 'USER_SESSIONS_DELETION_FAILED',
+                    details: error.message
+                }
+            };
+        }
+    }
+    /**
+     * Get all active sessions for a user
+     * @param clickupUserId ClickUp user ID
+     * @returns List of active sessions
+     */
+    async getUserSessions(clickupUserId) {
+        try {
+            this.logger.debug('Getting user sessions', { clickupUserId });
+            const userSessions = [];
+            const now = new Date();
+            for (const [sessionId, session] of this.sessions.entries()) {
+                if (session.clickupUserId === clickupUserId) {
+                    // Check if session is expired
+                    if (session.expiresAt <= now) {
+                        this.sessions.delete(sessionId);
+                    }
+                    else {
+                        userSessions.push(session);
+                    }
+                }
+            }
+            return {
+                success: true,
+                data: userSessions
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get user sessions', {
+                error: error.message,
+                clickupUserId
+            });
+            return {
+                success: false,
+                error: {
+                    message: 'Failed to get user sessions',
+                    code: 'USER_SESSIONS_RETRIEVAL_FAILED',
+                    details: error.message
+                }
+            };
+        }
+    }
+    /**
+     * Clean up expired sessions
+     * @private
+     */
+    async cleanupExpiredSessions() {
+        try {
+            this.logger.debug('Starting expired session cleanup');
+            const now = new Date();
+            let cleanedCount = 0;
+            for (const [sessionId, session] of this.sessions.entries()) {
+                if (session.expiresAt <= now) {
+                    this.sessions.delete(sessionId);
+                    cleanedCount++;
+                }
+            }
+            if (cleanedCount > 0) {
+                this.logger.info('Cleaned up expired sessions', {
+                    cleanedCount,
+                    remainingSessions: this.sessions.size
+                });
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to cleanup expired sessions', { error });
+        }
+    }
+    /**
+     * Generate unique session ID
+     * @private
+     */
+    generateSessionId() {
+        return 'sess_' + Math.random().toString(36).substring(2, 15) +
+            Math.random().toString(36).substring(2, 15) +
+            Date.now().toString(36);
+    }
+    /**
+     * Get session count (for monitoring)
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+}