@alanse/clickup-multi-mcp-server 1.0.0

package/build/services/clickup/document.js

@@ -0,0 +1,159 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 João Santana <joaosantana@gmail.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * Document service for ClickUp
+ *
+ * This service provides methods to manage ClickUp documents:
+ * - Create documents
+ * - Get document details
+ * - List documents in a container
+ * - List document pages
+ * - Get document pages content
+ * - Update document pages
+ */
+import { BaseClickUpService, ClickUpServiceError, ErrorCode } from './base.js';
+export class DocumentService extends BaseClickUpService {
+    constructor(apiKey, teamId, baseUrl) {
+        // Override baseUrl to use v3 API, since Docs are only available in v3
+        super(apiKey, teamId, baseUrl || 'https://api.clickup.com/api/v3');
+    }
+    /**
+     * Helper method to handle errors consistently
+     * @param error The error that occurred
+     * @param message Optional custom error message
+     * @returns A ClickUpServiceError
+     */
+    handleError(error, message) {
+        if (error instanceof ClickUpServiceError) {
+            return error;
+        }
+        return new ClickUpServiceError(message || `Document service error: ${error.message}`, ErrorCode.UNKNOWN, error);
+    }
+    /**
+     * Creates a new document in a space, folder, or list
+     * @param data - Document data with parent object structured as {id: string, type: number}
+     * @returns Created document
+     */
+    async createDocument(data) {
+        try {
+            // Log the request data for debugging
+            this.logOperation('Creating document with data:', { data });
+            const response = await this.client.post(`/workspaces/${this.teamId}/docs`, {
+                name: data.name,
+                parent: data.parent,
+                visibility: data.visibility || 'PRIVATE',
+                create_page: data.create_page !== undefined ? data.create_page : true
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to create document');
+        }
+    }
+    /**
+     * Creates a new page in a document
+     * @param documentId - ID of the document to create the page in
+     * @param data - Page data
+     * @returns Created page
+     */
+    async createPage(documentId, data) {
+        try {
+            this.logOperation('Creating page in document with data:', { documentId, data });
+            const response = await this.client.post(`/workspaces/${this.teamId}/docs/${documentId}/pages`, data);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to create page in document ${documentId}`);
+        }
+    }
+    /**
+     * Gets a document by ID
+     * @param documentId - ID of the document to retrieve
+     * @returns Document details
+     */
+    async getDocument(documentId) {
+        try {
+            this.logOperation('Getting document with ID:', { documentId });
+            const response = await this.client.get(`/workspaces/${this.teamId}/docs/${documentId}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get document ${documentId}`);
+        }
+    }
+    /**
+     * Lists documents in the workspace with optional filters
+     * @param options - Search and filter options
+     * @returns List of documents
+     */
+    async listDocuments(options = {}) {
+        try {
+            this.logOperation('Listing documents with options:', { options });
+            const response = await this.client.get(`/workspaces/${this.teamId}/docs`, {
+                params: options
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, 'Failed to list documents');
+        }
+    }
+    /**
+     * Lists all pages in a document with optional depth control
+     * @param documentId - ID of the document
+     * @param options - Options for page listing
+     * @returns List of document pages
+     */
+    async listDocumentPages(documentId, options = {}) {
+        try {
+            this.logOperation('Listing pages for document with ID:', { documentId, options });
+            const response = await this.client.get(`/workspaces/${this.teamId}/docs/${documentId}/pageListing`, { params: options });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to list pages for document ${documentId}`);
+        }
+    }
+    /**
+     * Gets the content of specific pages in a document
+     * @param documentId - ID of the document
+     * @param pageIds - Array of page IDs to retrieve
+     * @param options - Options for retrieving pages content
+     * @returns Document pages with content
+     */
+    async getDocumentPages(documentId, pageIds, options = {}) {
+        try {
+            // Get pages in parallel
+            this.logOperation('Getting pages for document with ID:', { documentId, pageIds, options });
+            const pagePromises = pageIds.map(pageId => this.client.get(`/workspaces/${this.teamId}/docs/${documentId}/pages/${pageId}`, { params: { ...options, pageIds } }));
+            const responses = await Promise.all(pagePromises);
+            const pages = responses.map(response => response.data);
+            return { pages };
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get pages for document ${documentId}`);
+        }
+    }
+    /**
+     * Updates an existing page in a document
+     * @param documentId - ID of the document containing the page
+     * @param pageId - ID of the page to update
+     * @param data - Updated page data
+     * @returns Updated page
+     */
+    async updatePage(documentId, pageId, data) {
+        try {
+            this.logOperation('Updating page in document with ID:', { documentId, pageId, data });
+            const response = await this.client.put(`/workspaces/${this.teamId}/docs/${documentId}/pages/${pageId}`, {
+                ...data,
+                content_format: data.content_format || 'text/md',
+                content_edit_mode: data.content_edit_mode || 'append'
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update page ${pageId} in document ${documentId}`);
+        }
+    }
+}

package/build/services/clickup/folder.js

@@ -0,0 +1,136 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Folder Service
+ *
+ * Handles all operations related to folders in ClickUp, including:
+ * - Creating folders
+ * - Retrieving folders
+ * - Updating folders
+ * - Deleting folders
+ * - Finding folders by name
+ */
+import { BaseClickUpService, ErrorCode, ClickUpServiceError } from './base.js';
+export class FolderService extends BaseClickUpService {
+    /**
+     * Creates an instance of FolderService
+     * @param apiKey - ClickUp API key
+     * @param teamId - ClickUp team ID
+     * @param baseUrl - Optional custom API URL
+     * @param workspaceService - Optional workspace service for lookups
+     */
+    constructor(apiKey, teamId, baseUrl, workspaceService) {
+        super(apiKey, teamId, baseUrl);
+        this.workspaceService = null;
+        this.workspaceService = workspaceService || null;
+    }
+    /**
+     * Helper method to handle errors consistently
+     * @param error The error that occurred
+     * @param message Optional custom error message
+     * @returns A ClickUpServiceError
+     */
+    handleError(error, message) {
+        if (error instanceof ClickUpServiceError) {
+            return error;
+        }
+        return new ClickUpServiceError(message || `Folder service error: ${error.message}`, ErrorCode.UNKNOWN, error);
+    }
+    /**
+     * Create a new folder in a space
+     * @param spaceId The ID of the space to create the folder in
+     * @param folderData The data for the new folder
+     * @returns The created folder
+     */
+    async createFolder(spaceId, folderData) {
+        try {
+            this.logOperation('createFolder', { spaceId, ...folderData });
+            const response = await this.client.post(`/space/${spaceId}/folder`, folderData);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to create folder in space ${spaceId}`);
+        }
+    }
+    /**
+     * Get a folder by its ID
+     * @param folderId The ID of the folder to retrieve
+     * @returns The folder details
+     */
+    async getFolder(folderId) {
+        try {
+            this.logOperation('getFolder', { folderId });
+            const response = await this.client.get(`/folder/${folderId}`);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get folder ${folderId}`);
+        }
+    }
+    /**
+     * Update an existing folder
+     * @param folderId The ID of the folder to update
+     * @param updateData The data to update on the folder
+     * @returns The updated folder
+     */
+    async updateFolder(folderId, updateData) {
+        try {
+            this.logOperation('updateFolder', { folderId, ...updateData });
+            const response = await this.client.put(`/folder/${folderId}`, updateData);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update folder ${folderId}`);
+        }
+    }
+    /**
+     * Delete a folder
+     * @param folderId The ID of the folder to delete
+     * @returns Success indicator
+     */
+    async deleteFolder(folderId) {
+        try {
+            this.logOperation('deleteFolder', { folderId });
+            await this.client.delete(`/folder/${folderId}`);
+            return {
+                success: true
+            };
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete folder ${folderId}`);
+        }
+    }
+    /**
+     * Get all folders in a space
+     * @param spaceId The ID of the space to get folders from
+     * @returns Array of folders in the space
+     */
+    async getFoldersInSpace(spaceId) {
+        this.logOperation('getFoldersInSpace', { spaceId });
+        try {
+            const response = await this.client.get(`/space/${spaceId}/folder`);
+            return response.data.folders;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get folders in space ${spaceId}`);
+        }
+    }
+    /**
+     * Find a folder by its name in a space
+     * @param spaceId The ID of the space to search in
+     * @param folderName The name of the folder to find
+     * @returns The folder if found, otherwise null
+     */
+    async findFolderByName(spaceId, folderName) {
+        this.logOperation('findFolderByName', { spaceId, folderName });
+        try {
+            const folders = await this.getFoldersInSpace(spaceId);
+            const matchingFolder = folders.find(folder => folder.name.toLowerCase() === folderName.toLowerCase());
+            return matchingFolder || null;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to find folder by name in space ${spaceId}`);
+        }
+    }
+}

package/build/services/clickup/index.js

@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp Service Entry Point
+ *
+ * This file re-exports all service modules for the ClickUp API integration.
+ * It also provides a convenient factory method to create instances of all services.
+ */
+// Export base service components
+export { BaseClickUpService, ClickUpServiceError, ErrorCode } from './base.js';
+// Export type definitions
+export * from './types.js';
+// Export service modules
+export { WorkspaceService } from './workspace.js';
+export { TaskService } from './task/index.js';
+export { ListService } from './list.js';
+export { FolderService } from './folder.js';
+export { ClickUpTagService } from './tag.js';
+export { TimeTrackingService } from './time.js';
+export { DocumentService } from './document.js';
+// Import service classes for the factory function
+import { WorkspaceService } from './workspace.js';
+import { TaskService } from './task/index.js';
+import { ListService } from './list.js';
+import { FolderService } from './folder.js';
+import { ClickUpTagService } from './tag.js';
+import { TimeTrackingService } from './time.js';
+import { Logger } from '../../logger.js';
+import { DocumentService } from './document.js';
+// Singleton logger for ClickUp services
+const logger = new Logger('ClickUpServices');
+/**
+ * Factory function to create instances of all ClickUp services
+ * @param config Configuration for the services
+ * @returns Object containing all service instances
+ */
+export function createClickUpServices(config) {
+    const { apiKey, teamId, baseUrl } = config;
+    // Log start of overall initialization
+    logger.info('Starting ClickUp services initialization', {
+        teamId,
+        baseUrl: baseUrl || 'https://api.clickup.com/api/v2'
+    });
+    // Create workspace service first since others depend on it
+    logger.info('Initializing ClickUp Workspace service');
+    const workspaceService = new WorkspaceService(apiKey, teamId, baseUrl);
+    // Initialize remaining services with workspace dependency
+    logger.info('Initializing ClickUp Task service');
+    const taskService = new TaskService(apiKey, teamId, baseUrl, workspaceService);
+    logger.info('Initializing ClickUp List service');
+    const listService = new ListService(apiKey, teamId, baseUrl, workspaceService);
+    logger.info('Initializing ClickUp Folder service');
+    const folderService = new FolderService(apiKey, teamId, baseUrl, workspaceService);
+    logger.info('Initializing ClickUp Tag service');
+    const tagService = new ClickUpTagService(apiKey, teamId, baseUrl);
+    logger.info('Initializing ClickUp Time Tracking service');
+    const timeTrackingService = new TimeTrackingService(apiKey, teamId, baseUrl);
+    logger.info('Initializing ClickUp Document service');
+    const documentService = new DocumentService(apiKey, teamId, baseUrl);
+    const services = {
+        workspace: workspaceService,
+        task: taskService,
+        list: listService,
+        folder: folderService,
+        tag: tagService,
+        timeTracking: timeTrackingService,
+        document: documentService
+    };
+    // Log successful completion
+    logger.info('All ClickUp services initialized successfully', {
+        services: Object.keys(services),
+        baseUrl: baseUrl || 'https://api.clickup.com/api/v2'
+    });
+    return services;
+}

package/build/services/clickup/list.js

@@ -0,0 +1,191 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * ClickUp List Service
+ *
+ * Handles all operations related to lists in ClickUp, including:
+ * - Creating lists
+ * - Retrieving lists
+ * - Updating lists
+ * - Deleting lists
+ * - Finding lists by name
+ */
+import { BaseClickUpService, ErrorCode, ClickUpServiceError } from './base.js';
+export class ListService extends BaseClickUpService {
+    constructor(apiKey, teamId, baseUrl, workspaceService) {
+        super(apiKey, teamId, baseUrl);
+        this.workspaceService = null;
+        this.workspaceService = workspaceService || null;
+    }
+    /**
+     * Helper method to handle errors consistently
+     * @param error The error that occurred
+     * @param message Optional custom error message
+     * @returns A ClickUpServiceError
+     */
+    handleError(error, message) {
+        if (error instanceof ClickUpServiceError) {
+            return error;
+        }
+        return new ClickUpServiceError(message || `List service error: ${error.message}`, ErrorCode.UNKNOWN, error);
+    }
+    /**
+     * Create a new list in a space
+     * @param spaceId The ID of the space to create the list in
+     * @param listData The data for the new list
+     * @returns The created list
+     */
+    async createList(spaceId, listData) {
+        this.logOperation('createList', { spaceId, ...listData });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.post(`/space/${spaceId}/list`, listData);
+                return response.data;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to create list in space ${spaceId}`);
+        }
+    }
+    /**
+     * Create a new list in a folder
+     * @param folderId The ID of the folder to create the list in
+     * @param listData The data for the new list
+     * @returns The created list
+     */
+    async createListInFolder(folderId, listData) {
+        this.logOperation('createListInFolder', { folderId, ...listData });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.post(`/folder/${folderId}/list`, listData);
+                return response.data;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to create list in folder ${folderId}`);
+        }
+    }
+    /**
+     * Get a list by ID
+     * @param listId The ID of the list to retrieve
+     * @returns The requested list
+     */
+    async getList(listId) {
+        this.logOperation('getList', { listId });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.get(`/list/${listId}`);
+                return response.data;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get list ${listId}`);
+        }
+    }
+    /**
+     * Update an existing list
+     * @param listId The ID of the list to update
+     * @param updateData The data to update on the list
+     * @returns The updated list
+     */
+    async updateList(listId, updateData) {
+        this.logOperation('updateList', { listId, ...updateData });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.put(`/list/${listId}`, updateData);
+                return response.data;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to update list ${listId}`);
+        }
+    }
+    /**
+     * Delete a list
+     * @param listId The ID of the list to delete
+     * @returns Success indicator
+     */
+    async deleteList(listId) {
+        this.logOperation('deleteList', { listId });
+        try {
+            await this.makeRequest(async () => {
+                await this.client.delete(`/list/${listId}`);
+            });
+            return {
+                success: true
+            };
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to delete list ${listId}`);
+        }
+    }
+    /**
+     * Get all lists in a space
+     * @param spaceId The ID of the space to get lists from
+     * @returns Array of lists in the space
+     */
+    async getListsInSpace(spaceId) {
+        this.logOperation('getListsInSpace', { spaceId });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.get(`/space/${spaceId}/list`);
+                return response.data.lists;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get lists in space ${spaceId}`);
+        }
+    }
+    /**
+     * Get all lists in a folder
+     * @param folderId The ID of the folder to get lists from
+     * @returns Array of lists in the folder
+     */
+    async getListsInFolder(folderId) {
+        this.logOperation('getListsInFolder', { folderId });
+        try {
+            return await this.makeRequest(async () => {
+                const response = await this.client.get(`/folder/${folderId}/list`);
+                return response.data.lists;
+            });
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to get lists in folder ${folderId}`);
+        }
+    }
+    /**
+     * Find a list by its name in a space
+     * @param spaceId The ID of the space to search in
+     * @param listName The name of the list to find
+     * @returns The list if found, otherwise null
+     */
+    async findListByNameInSpace(spaceId, listName) {
+        this.logOperation('findListByNameInSpace', { spaceId, listName });
+        try {
+            const lists = await this.getListsInSpace(spaceId);
+            const matchingList = lists.find(list => list.name.toLowerCase() === listName.toLowerCase());
+            return matchingList || null;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to find list by name in space ${spaceId}`);
+        }
+    }
+    /**
+     * Find a list by its name in a folder
+     * @param folderId The ID of the folder to search in
+     * @param listName The name of the list to find
+     * @returns The list if found, otherwise null
+     */
+    async findListByNameInFolder(folderId, listName) {
+        this.logOperation('findListByNameInFolder', { folderId, listName });
+        try {
+            const lists = await this.getListsInFolder(folderId);
+            const matchingList = lists.find(list => list.name.toLowerCase() === listName.toLowerCase());
+            return matchingList || null;
+        }
+        catch (error) {
+            throw this.handleError(error, `Failed to find list by name in folder ${folderId}`);
+        }
+    }
+}