@taazkareem/clickup-mcp-server 0.8.5 → 0.9.1

package/build/services/clickup/adapter.js

@@ -0,0 +1,281 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Service Adapter
+ *
+ * Provides backward compatibility for existing ClickUp services
+ * while supporting both API key and OAuth2 authentication.
+ * This adapter wraps the existing services without modifying their constructors.
+ */
+import { WorkspaceService } from './workspace.js';
+import { TaskService } from './task/task-service.js';
+import { ListService } from './list.js';
+import { FolderService } from './folder.js';
+import { TimeService } from './time.js';
+import { TagService } from './tag.js';
+import { BulkService } from './bulk.js';
+import { DocumentService } from './document.js';
+import { Logger } from '../../logger.js';
+import config from '../../config.js';
+/**
+ * ClickUp service adapter that provides authentication-aware service creation
+ */
+export class ClickUpServiceAdapter {
+    constructor() {
+        this.logger = new Logger('ClickUpServiceAdapter');
+    }
+    /**
+     * Get authentication parameters from context
+     * @private
+     */
+    getAuthParams(context) {
+        if (context.authMethod === 'oauth2') {
+            if (!context.accessToken) {
+                throw new Error('OAuth2 access token is required but not provided');
+            }
+            if (!context.teamId) {
+                throw new Error('Team ID is required for OAuth2 authentication');
+            }
+            // For OAuth2, we'll use the access token as the "API key" 
+            // and modify the service after creation
+            return {
+                apiKey: `Bearer ${context.accessToken}`,
+                teamId: context.teamId
+            };
+        }
+        else {
+            // API key authentication
+            const apiKey = context.apiKey || config.clickupApiKey;
+            const teamId = context.teamId || config.clickupTeamId;
+            if (!apiKey) {
+                throw new Error('API key is required but not provided');
+            }
+            if (!teamId) {
+                throw new Error('Team ID is required but not provided');
+            }
+            return { apiKey, teamId };
+        }
+    }
+    /**
+     * Create AuthConfig from context
+     * @private
+     */
+    createAuthConfig(context) {
+        if (context.authMethod === 'oauth2') {
+            if (!context.accessToken) {
+                throw new Error('Access token is required for OAuth2 authentication');
+            }
+            return {
+                type: 'oauth2',
+                accessToken: context.accessToken,
+                teamId: context.teamId || config.clickupTeamId
+            };
+        }
+        else {
+            const apiKey = context.apiKey || config.clickupApiKey;
+            const teamId = context.teamId || config.clickupTeamId;
+            if (!apiKey) {
+                throw new Error('API key is required for API key authentication');
+            }
+            return {
+                type: 'api_key',
+                apiKey,
+                teamId
+            };
+        }
+    }
+    /**
+     * Create WorkspaceService instance
+     */
+    createWorkspaceService(context) {
+        try {
+            const { apiKey, teamId } = this.getAuthParams(context);
+            const service = WorkspaceService.withApiKey(apiKey, teamId);
+            this.logger.debug('WorkspaceService created', {
+                authMethod: context.authMethod,
+                teamId
+            });
+            return service;
+        }
+        catch (error) {
+            this.logger.error('Failed to create WorkspaceService', {
+                error: error.message,
+                context
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create TaskService instance
+     */
+    createTaskService(context) {
+        try {
+            const { apiKey, teamId } = this.getAuthParams(context);
+            const service = TaskService.withApiKey(apiKey, teamId);
+            this.logger.debug('TaskService created', {
+                authMethod: context.authMethod,
+                teamId
+            });
+            return service;
+        }
+        catch (error) {
+            this.logger.error('Failed to create TaskService', {
+                error: error.message,
+                context
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create ListService instance
+     */
+    createListService(context) {
+        try {
+            const { apiKey, teamId } = this.getAuthParams(context);
+            const service = new ListService(apiKey, teamId);
+            this.logger.debug('ListService created', {
+                authMethod: context.authMethod,
+                teamId
+            });
+            return service;
+        }
+        catch (error) {
+            this.logger.error('Failed to create ListService', {
+                error: error.message,
+                context
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create FolderService instance
+     */
+    createFolderService(context) {
+        try {
+            const { apiKey, teamId } = this.getAuthParams(context);
+            const service = new FolderService(apiKey, teamId);
+            this.logger.debug('FolderService created', {
+                authMethod: context.authMethod,
+                teamId
+            });
+            return service;
+        }
+        catch (error) {
+            this.logger.error('Failed to create FolderService', {
+                error: error.message,
+                context
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create TimeService instance
+     */
+    createTimeService(context) {
+        try {
+            const authConfig = this.createAuthConfig(context);
+            const apiKey = authConfig.type === 'api_key' ? authConfig.apiKey : authConfig.accessToken;
+            const service = new TimeService(apiKey, authConfig.teamId);
+            this.logger.debug('TimeService created', {
+                authMethod: context.authMethod,
+                teamId: authConfig.teamId
+            });
+            return service;
+        }
+        catch (error) {
+            this.logger.error('Failed to create TimeService', {
+                error: error.message,
+                context
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create TagService instance
+     */
+    createTagService(context) {
+        try {
+            const authConfig = this.createAuthConfig(context);
+            const apiKey = authConfig.type === 'api_key' ? authConfig.apiKey : authConfig.accessToken;
+            const service = new TagService(apiKey, authConfig.teamId);
+            this.logger.debug('TagService created', {
+                authMethod: context.authMethod,
+                teamId: authConfig.teamId
+            });
+            return service;
+        }
+        catch (error) {
+            this.logger.error('Failed to create TagService', {
+                error: error.message,
+                context
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create BulkService instance
+     */
+    createBulkService(context) {
+        try {
+            // BulkService needs a TaskService instance
+            const taskService = this.createTaskService(context);
+            const service = new BulkService(taskService);
+            this.logger.debug('BulkService created', {
+                authMethod: context.authMethod,
+                teamId: context.teamId
+            });
+            return service;
+        }
+        catch (error) {
+            this.logger.error('Failed to create BulkService', {
+                error: error.message,
+                context
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create DocumentService instance
+     */
+    createDocumentService(context) {
+        try {
+            const { apiKey, teamId } = this.getAuthParams(context);
+            const service = new DocumentService(apiKey, teamId);
+            this.logger.debug('DocumentService created', {
+                authMethod: context.authMethod,
+                teamId
+            });
+            return service;
+        }
+        catch (error) {
+            this.logger.error('Failed to create DocumentService', {
+                error: error.message,
+                context
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create service context from API key authentication (backward compatibility)
+     */
+    static createApiKeyContext(apiKey, teamId) {
+        return {
+            authMethod: 'api_key',
+            apiKey: apiKey || config.clickupApiKey,
+            teamId: teamId || config.clickupTeamId
+        };
+    }
+    /**
+     * Create service context from OAuth2 authentication
+     */
+    static createOAuth2Context(accessToken, teamId, userId, clickupUserId) {
+        return {
+            authMethod: 'oauth2',
+            accessToken,
+            teamId,
+            userId,
+            clickupUserId
+        };
+    }
+}

package/build/services/clickup/factory.js

@@ -0,0 +1,339 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Service Factory
+ *
+ * Creates ClickUp service instances with appropriate authentication
+ * based on the request context (OAuth2 or API key).
+ */
+import { WorkspaceService } from './workspace.js';
+import { TaskService } from './task/task-service.js';
+import { ListService } from './list.js';
+import { FolderService } from './folder.js';
+import { TimeService } from './time.js';
+import { TagService } from './tag.js';
+import { BulkService } from './bulk.js';
+import { DocumentService } from './document.js';
+import { Logger } from '../../logger.js';
+import config from '../../config.js';
+/**
+ * Factory class for creating ClickUp services with appropriate authentication
+ */
+export class ClickUpServiceFactory {
+    constructor() {
+        this.logger = new Logger('ClickUpServiceFactory');
+    }
+    /**
+     * Create authentication configuration from service context
+     * @private
+     */
+    createAuthConfig(context) {
+        if (context.authMethod === 'oauth2') {
+            if (!context.accessToken) {
+                throw new Error('OAuth2 access token is required but not provided');
+            }
+            if (!context.teamId) {
+                throw new Error('Team ID is required for OAuth2 authentication');
+            }
+            return {
+                type: 'oauth2',
+                accessToken: context.accessToken,
+                teamId: context.teamId
+            };
+        }
+        else {
+            // API key authentication
+            const apiKey = context.apiKey || config.clickupApiKey;
+            const teamId = context.teamId || config.clickupTeamId;
+            if (!apiKey) {
+                throw new Error('API key is required but not provided');
+            }
+            if (!teamId) {
+                throw new Error('Team ID is required but not provided');
+            }
+            return {
+                type: 'api_key',
+                apiKey,
+                teamId
+            };
+        }
+    }
+    /**
+     * Create WorkspaceService instance
+     */
+    createWorkspaceService(context) {
+        try {
+            const authConfig = this.createAuthConfig(context);
+            const service = new WorkspaceService(authConfig);
+            this.logger.debug('WorkspaceService created', {
+                authMethod: context.authMethod,
+                teamId: authConfig.teamId
+            });
+            return {
+                success: true,
+                service
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create WorkspaceService', {
+                error: error.message,
+                context
+            });
+            return {
+                success: false,
+                error: {
+                    message: error.message,
+                    code: 'SERVICE_CREATION_FAILED'
+                }
+            };
+        }
+    }
+    /**
+     * Create TaskService instance
+     */
+    createTaskService(context) {
+        try {
+            const authConfig = this.createAuthConfig(context);
+            const apiKey = authConfig.type === 'api_key' ? authConfig.apiKey : authConfig.accessToken;
+            // Create workspace service first
+            const workspaceService = new WorkspaceService(authConfig);
+            const service = new TaskService(apiKey, authConfig.teamId, undefined, workspaceService);
+            this.logger.debug('TaskService created', {
+                authMethod: context.authMethod,
+                teamId: authConfig.teamId
+            });
+            return {
+                success: true,
+                service
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create TaskService', {
+                error: error.message,
+                context
+            });
+            return {
+                success: false,
+                error: {
+                    message: error.message,
+                    code: 'SERVICE_CREATION_FAILED'
+                }
+            };
+        }
+    }
+    /**
+     * Create ListService instance
+     */
+    createListService(context) {
+        try {
+            const authConfig = this.createAuthConfig(context);
+            const apiKey = authConfig.type === 'api_key' ? authConfig.apiKey : authConfig.accessToken;
+            const service = new ListService(apiKey, authConfig.teamId);
+            this.logger.debug('ListService created', {
+                authMethod: context.authMethod,
+                teamId: authConfig.teamId
+            });
+            return {
+                success: true,
+                service
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create ListService', {
+                error: error.message,
+                context
+            });
+            return {
+                success: false,
+                error: {
+                    message: error.message,
+                    code: 'SERVICE_CREATION_FAILED'
+                }
+            };
+        }
+    }
+    /**
+     * Create FolderService instance
+     */
+    createFolderService(context) {
+        try {
+            const authConfig = this.createAuthConfig(context);
+            const apiKey = authConfig.type === 'api_key' ? authConfig.apiKey : authConfig.accessToken;
+            const service = new FolderService(apiKey, authConfig.teamId);
+            this.logger.debug('FolderService created', {
+                authMethod: context.authMethod,
+                teamId: authConfig.teamId
+            });
+            return {
+                success: true,
+                service
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create FolderService', {
+                error: error.message,
+                context
+            });
+            return {
+                success: false,
+                error: {
+                    message: error.message,
+                    code: 'SERVICE_CREATION_FAILED'
+                }
+            };
+        }
+    }
+    /**
+     * Create TimeService instance
+     */
+    createTimeService(context) {
+        try {
+            const authConfig = this.createAuthConfig(context);
+            const apiKey = authConfig.type === 'api_key' ? authConfig.apiKey : authConfig.accessToken;
+            const service = new TimeService(apiKey, authConfig.teamId);
+            this.logger.debug('TimeService created', {
+                authMethod: context.authMethod,
+                teamId: authConfig.teamId
+            });
+            return {
+                success: true,
+                service
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create TimeService', {
+                error: error.message,
+                context
+            });
+            return {
+                success: false,
+                error: {
+                    message: error.message,
+                    code: 'SERVICE_CREATION_FAILED'
+                }
+            };
+        }
+    }
+    /**
+     * Create TagService instance
+     */
+    createTagService(context) {
+        try {
+            const authConfig = this.createAuthConfig(context);
+            const apiKey = authConfig.type === 'api_key' ? authConfig.apiKey : authConfig.accessToken;
+            const service = new TagService(apiKey, authConfig.teamId);
+            this.logger.debug('TagService created', {
+                authMethod: context.authMethod,
+                teamId: authConfig.teamId
+            });
+            return {
+                success: true,
+                service
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create TagService', {
+                error: error.message,
+                context
+            });
+            return {
+                success: false,
+                error: {
+                    message: error.message,
+                    code: 'SERVICE_CREATION_FAILED'
+                }
+            };
+        }
+    }
+    /**
+     * Create BulkService instance
+     */
+    createBulkService(context) {
+        try {
+            // BulkService needs a TaskService instance
+            const taskServiceResult = this.createTaskService(context);
+            if (!taskServiceResult.success) {
+                return {
+                    success: false,
+                    error: taskServiceResult.error
+                };
+            }
+            const service = new BulkService(taskServiceResult.service);
+            this.logger.debug('BulkService created', {
+                authMethod: context.authMethod,
+                teamId: context.teamId
+            });
+            return {
+                success: true,
+                service
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create BulkService', {
+                error: error.message,
+                context
+            });
+            return {
+                success: false,
+                error: {
+                    message: error.message,
+                    code: 'SERVICE_CREATION_FAILED'
+                }
+            };
+        }
+    }
+    /**
+     * Create DocumentService instance
+     */
+    createDocumentService(context) {
+        try {
+            const authConfig = this.createAuthConfig(context);
+            const apiKey = authConfig.type === 'api_key' ? authConfig.apiKey : authConfig.accessToken;
+            const service = new DocumentService(apiKey, authConfig.teamId);
+            this.logger.debug('DocumentService created', {
+                authMethod: context.authMethod,
+                teamId: authConfig.teamId
+            });
+            return {
+                success: true,
+                service
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create DocumentService', {
+                error: error.message,
+                context
+            });
+            return {
+                success: false,
+                error: {
+                    message: error.message,
+                    code: 'SERVICE_CREATION_FAILED'
+                }
+            };
+        }
+    }
+    /**
+     * Create service context from API key authentication (backward compatibility)
+     */
+    static createApiKeyContext(apiKey, teamId) {
+        return {
+            authMethod: 'api_key',
+            apiKey: apiKey || config.clickupApiKey,
+            teamId: teamId || config.clickupTeamId
+        };
+    }
+    /**
+     * Create service context from OAuth2 authentication
+     */
+    static createOAuth2Context(accessToken, teamId, userId, clickupUserId) {
+        return {
+            authMethod: 'oauth2',
+            accessToken,
+            teamId,
+            userId,
+            clickupUserId
+        };
+    }
+}

package/build/services/clickup/task/task-attachments.js

@@ -8,12 +8,20 @@
  * - Uploading file attachments from base64/buffer data
  * - Uploading file attachments from a URL (web URLs like http/https)
  * - Uploading file attachments from local file paths (absolute paths)
+ *
+ * REFACTORED: Now uses composition instead of inheritance.
+ * Only depends on TaskServiceCore for base functionality.
  */
-import { TaskServiceSearch } from './task-search.js';
 /**
  * Attachment functionality for the TaskService
+ *
+ * This service handles all file attachment operations for ClickUp tasks.
+ * It uses composition to access core functionality instead of inheritance.
  */
-export class TaskServiceAttachments extends TaskServiceSearch {
+export class TaskServiceAttachments {
+    constructor(core) {
+        this.core = core;
+    }
     /**
      * Upload a file attachment to a ClickUp task
      * @param taskId The ID of the task to attach the file to
@@ -22,9 +30,9 @@ export class TaskServiceAttachments extends TaskServiceSearch {
      * @returns Promise resolving to the attachment response from ClickUp
      */
     async uploadTaskAttachment(taskId, fileData, fileName) {
-        this.logOperation('uploadTaskAttachment', { taskId, fileName, fileSize: fileData.length });
+        this.core.logOperation('uploadTaskAttachment', { taskId, fileName, fileSize: fileData.length });
         try {
-            return await this.makeRequest(async () => {
+            return await this.core.makeRequest(async () => {
                 // Create FormData for multipart/form-data upload
                 const FormData = (await import('form-data')).default;
                 const formData = new FormData();
@@ -34,17 +42,17 @@ export class TaskServiceAttachments extends TaskServiceSearch {
                     contentType: 'application/octet-stream' // Let ClickUp determine the content type
                 });
                 // Use the raw axios client for this request since we need to handle FormData
-                const response = await this.client.post(`/task/${taskId}/attachment`, formData, {
+                const response = await this.core.client.post(`/task/${taskId}/attachment`, formData, {
                     headers: {
                         ...formData.getHeaders(),
-                        'Authorization': this.apiKey
+                        'Authorization': this.core.apiKey
                     }
                 });
                 return response.data;
             });
         }
         catch (error) {
-            throw this.handleError(error, `Failed to upload attachment to task ${taskId}`);
+            throw this.core.handleError(error, `Failed to upload attachment to task ${taskId}`);
         }
     }
     /**
@@ -56,9 +64,9 @@ export class TaskServiceAttachments extends TaskServiceSearch {
      * @returns Promise resolving to the attachment response from ClickUp
      */
     async uploadTaskAttachmentFromUrl(taskId, fileUrl, fileName, authHeader) {
-        this.logOperation('uploadTaskAttachmentFromUrl', { taskId, fileUrl, fileName });
+        this.core.logOperation('uploadTaskAttachmentFromUrl', { taskId, fileUrl, fileName });
         try {
-            return await this.makeRequest(async () => {
+            return await this.core.makeRequest(async () => {
                 // Import required modules
                 const axios = (await import('axios')).default;
                 const FormData = (await import('form-data')).default;
@@ -81,17 +89,17 @@ export class TaskServiceAttachments extends TaskServiceSearch {
                     contentType: 'application/octet-stream'
                 });
                 // Upload the file to ClickUp
-                const uploadResponse = await this.client.post(`/task/${taskId}/attachment`, formData, {
+                const uploadResponse = await this.core.client.post(`/task/${taskId}/attachment`, formData, {
                     headers: {
                         ...formData.getHeaders(),
-                        'Authorization': this.apiKey
+                        'Authorization': this.core.apiKey
                     }
                 });
                 return uploadResponse.data;
             });
         }
         catch (error) {
-            throw this.handleError(error, `Failed to upload attachment from URL to task ${taskId}`);
+            throw this.core.handleError(error, `Failed to upload attachment from URL to task ${taskId}`);
         }
     }
 }