@taazkareem/clickup-mcp-server 0.4.0 → 0.4.2

package/README.md

@@ -45,16 +45,11 @@ A Model Context Protocol (MCP) server for integrating ClickUp tasks with AI appl
 
 ## Installation
 
-### Using npx (Recommended)
+### Using npx
 ```bash
 npx @taazkareem/clickup-mcp-server
 ```
 
-### Global Installation
-```bash
-npm install -g @taazkareem/clickup-mcp-server
-```
-
 ## Configuration
 
 1. Get your ClickUp API key from [ClickUp Settings](https://app.clickup.com/settings/apps)
@@ -64,7 +59,7 @@ CLICKUP_API_KEY=your_api_key_here
 TEAM_ID=your_team_id_here
 ```
 
-## Using with Cursor AI Composer
+## Using with Cursor AI Composer Agent
 
 To add this server to Cursor AI Composer, follow these steps:
 
@@ -72,17 +67,13 @@ To add this server to Cursor AI Composer, follow these steps:
 2. Add the following command under MCP Servers:
 
 ```bash
-npx -y @taazkareem/clickup-mcp-server \
+npx -y @taazkareem/clickup-mcp-server --stdio \
   --env CLICKUP_API_KEY=your_api_key_here \
   --env TEAM_ID=your_team_id_here
 ```
 3. Replace `your_api_key_here` and `your_team_id_here` with your actual ClickUp credentials.
 4. Click on 'Save' to add the server.
 
-You can get these values from:
-- `CLICKUP_API_KEY`: Get from [ClickUp Settings > Apps](https://app.clickup.com/settings/apps)
-- `TEAM_ID`: Your ClickUp Team ID (found in the URL when viewing your workspace or via API)
-
 > **Security Note**: Your API key will be stored securely and will not be exposed to AI models.
 
 ### Available Tools
@@ -246,4 +237,4 @@ Contributions are welcome! Please read our [Contributing Guide](CONTRIBUTING.md)
 
 ## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. 
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/build/config.js

@@ -1,8 +1,13 @@
 import dotenv from 'dotenv';
 // Load environment variables from .env file
 dotenv.config();
+console.log('Environment variables received:', {
+    CLICKUP_API_KEY: process.env.CLICKUP_API_KEY,
+    TEAM_ID: process.env.TEAM_ID
+});
 // Parse command line arguments for --env flags
 const args = process.argv.slice(2);
+console.log('Command line arguments:', args);
 const envArgs = {};
 for (let i = 0; i < args.length; i++) {
     if (args[i] === '--env' && i + 1 < args.length) {
@@ -14,10 +19,12 @@ for (let i = 0; i < args.length; i++) {
         i++; // Skip the next argument since we used it
     }
 }
+console.log('Parsed environment arguments:', envArgs);
 const configuration = {
     clickupApiKey: envArgs.clickupApiKey || process.env.CLICKUP_API_KEY || '',
-    teamId: envArgs.teamId || process.env.TEAM_ID || '',
+    teamId: envArgs.teamId || process.env.TEAM_ID || ''
 };
+console.log('Final configuration:', configuration);
 // Check for missing environment variables
 const missingEnvVars = Object.entries(configuration)
     .filter(([_, value]) => !value)

package/build/handlers/prompts.js

@@ -0,0 +1,25 @@
+import { getAllTasks } from '../utils/resolvers.js';
+export async function handleSummarizeTasks(clickup, teamId) {
+    const { tasks } = await getAllTasks(clickup, teamId);
+    let output = "Summarized Tasks:\n\n";
+    for (const task of tasks) {
+        output += `- ${task.name}: ${task.description}\n`;
+    }
+    return output;
+}
+export async function handleAnalyzeTaskPriorities(clickup, teamId) {
+    const { tasks } = await getAllTasks(clickup, teamId);
+    const priorities = tasks.map(task => task.priority?.priority);
+    const uniquePriorities = [...new Set(priorities.filter(p => p !== undefined))];
+    const priorityCounts = uniquePriorities.map(priority => ({
+        priority,
+        count: priorities.filter(p => p === priority).length
+    }));
+    let output = "Task Priorities Analysis:\n\n";
+    output += "Available Priorities: " + uniquePriorities.join(', ') + "\n\n";
+    output += "Priority Counts:\n";
+    for (const priority of priorityCounts) {
+        output += `- Priority ${priority.priority}: ${priority.count}\n`;
+    }
+    return output;
+}

package/build/handlers/tools.js

@@ -0,0 +1,38 @@
+import { resolveListId } from '../utils/resolvers.js';
+export async function handleWorkspaceHierarchy(clickup, teamId) {
+    const spaces = await clickup.getSpaces(teamId);
+    const allLists = await clickup.getAllLists(teamId);
+    let output = "ClickUp Workspace Hierarchy:\n\n";
+    for (const space of spaces) {
+        output += `Space: ${space.name} (ID: ${space.id})\n`;
+        const folders = await clickup.getFolders(space.id);
+        for (const folder of folders) {
+            output += `  ├─ Folder: ${folder.name} (ID: ${folder.id})\n`;
+            const folderLists = folder.lists || [];
+            for (const list of folderLists) {
+                const { statuses } = await clickup.getTasks(list.id);
+                output += `  │  └─ List: ${list.name} (ID: ${list.id})\n`;
+                output += `  │     Available Statuses: ${statuses.join(', ')}\n`;
+            }
+        }
+        const spaceLists = allLists.filter(list => list.space &&
+            list.space.id === space.id &&
+            !folders.some(folder => folder.lists?.some(fl => fl.id === list.id)));
+        if (spaceLists.length > 0) {
+            output += "  ├─ Lists (not in folders):\n";
+            for (const list of spaceLists) {
+                const { statuses } = await clickup.getTasks(list.id);
+                output += `  │  └─ List: ${list.name} (ID: ${list.id})\n`;
+                output += `  │     Available Statuses: ${statuses.join(', ')}\n`;
+            }
+        }
+        output += "\n";
+    }
+    return output;
+}
+export async function handleCreateTask(clickup, teamId, args) {
+    const listId = await resolveListId(clickup, teamId, args.listId, args.listName);
+    const { listId: _, listName: __, ...taskData } = args;
+    return await clickup.createTask(listId, taskData);
+}
+// Add other handler functions for each tool... 

package/build/index.js

@@ -1,36 +1,31 @@
 #!/usr/bin/env node
-/**
- * This is a template MCP server that implements a simple ClickUp task management system.
- * It demonstrates core MCP concepts like resources, tools, and prompts by allowing:
- * - Listing ClickUp tasks as resources
- * - Reading individual ClickUp tasks
- * - Creating new ClickUp tasks via a tool
- * - Updating existing ClickUp tasks via a tool
- * - Summarizing all ClickUp tasks via a prompt
- * - Analyzing task priorities via a prompt
- * - Generating detailed descriptions for tasks via a prompt
- */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { ClickUpService } from "./services/clickup.js";
 import config from "./config.js";
-/**
- * Simple in-memory storage for notes.
- * In a real implementation, this would likely be backed by a database.
- */
-const notes = {
-    "1": { title: "First Note", content: "This is note 1" },
-    "2": { title: "Second Note", content: "This is note 2" }
-};
+import { handleWorkspaceHierarchy, handleCreateTask } from "./handlers/tools.js";
+import { handleSummarizeTasks, handleAnalyzeTaskPriorities } from "./handlers/prompts.js";
+import { getAllTasks } from "./utils/resolvers.js";
+console.log('Server starting up...');
+console.log('Config loaded:', {
+    clickupApiKey: config.clickupApiKey ? '***' : 'missing',
+    teamId: config.teamId || 'missing'
+});
 // Initialize ClickUp service
-const clickup = ClickUpService.initialize(config.clickupApiKey);
-/**
- * Create an MCP server with capabilities for resources (to list/read ClickUp tasks),
- * tools (to create/update ClickUp tasks), and prompts (to summarize/analyze ClickUp tasks).
- */
+let clickup;
+try {
+    console.log('Initializing ClickUp service...');
+    clickup = ClickUpService.initialize(config.clickupApiKey);
+    console.log('ClickUp service initialized successfully');
+}
+catch (error) {
+    console.error("Failed to initialize ClickUp service:", error);
+    process.exit(1);
+}
+console.log('Creating MCP server...');
 const server = new Server({
-    name: "clickup-mcp-server",
+    name: "clickup",
     version: "0.1.0",
 }, {
     capabilities: {
@@ -39,40 +34,31 @@ const server = new Server({
         prompts: {},
     },
 });
+console.log('MCP server created');
 /**
  * Handler for listing available ClickUp tasks as resources.
- * Each task is exposed as a resource with:
- * - A clickup:// URI scheme
- * - JSON MIME type
- * - Human readable name and description (including the task name and description)
  */
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    console.log('Handling ListResources request');
     try {
-        const spaces = await clickup.getSpaces(config.teamId);
-        const resources = [];
-        for (const space of spaces) {
-            const lists = await clickup.getLists(space.id);
-            for (const list of lists) {
-                const { tasks } = await clickup.getTasks(list.id);
-                resources.push(...tasks.map((task) => ({
-                    uri: `clickup://task/${task.id}`,
-                    mimeType: "application/json",
-                    name: task.name,
-                    description: task.description || `Task in ${list.name} (${space.name})`,
-                    tags: []
-                })));
-            }
-        }
-        return { resources };
+        const { tasks, spaces } = await getAllTasks(clickup, config.teamId);
+        return {
+            resources: tasks.map(task => ({
+                uri: `clickup://task/${task.id}`,
+                mimeType: "application/json",
+                name: task.name,
+                description: task.description || `Task in ${task.list.name} (${task.space.name})`,
+                tags: []
+            }))
+        };
     }
     catch (error) {
-        console.error('Error listing resources:', error);
+        console.error('Error in ListResources:', error);
         throw error;
     }
 });
 /**
  * Handler for reading the contents of a specific ClickUp task.
- * Takes a clickup:// URI and returns the task content as JSON.
  */
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     try {
@@ -94,15 +80,15 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     }
 });
 /**
- * Handler that lists available tools.
- * Exposes tools for listing spaces, creating tasks, and updating tasks.
+ * Handler for listing available tools.
  */
 server.setRequestHandler(ListToolsRequestSchema, async () => {
+    console.log('Handling ListTools request');
     return {
         tools: [
             {
                 name: "workspace_hierarchy",
-                description: "List complete hierarchy of the ClickUp workspace, including spaces, folders, lists, and their IDs and available statuses",
+                description: "List complete hierarchy of the ClickUp workspace",
                 inputSchema: {
                     type: "object",
                     properties: {},
@@ -390,54 +376,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     };
 });
 /**
- * Handler for the CallToolRequestSchema.
- * Handles the execution of tools like listing spaces, creating tasks, and updating tasks.
+ * Handler for executing tools.
  */
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         switch (request.params.name) {
             case "workspace_hierarchy": {
-                const spaces = await clickup.getSpaces(config.teamId);
-                const allLists = await clickup.getAllLists(config.teamId);
-                let output = "ClickUp Workspace Hierarchy:\n\n";
-                for (const space of spaces) {
-                    output += `Space: ${space.name} (ID: ${space.id})\n`;
-                    // Get folders in this space
-                    const folders = await clickup.getFolders(space.id);
-                    for (const folder of folders) {
-                        output += `  ├─ Folder: ${folder.name} (ID: ${folder.id})\n`;
-                        // Get lists in this folder
-                        const folderLists = folder.lists || [];
-                        for (const list of folderLists) {
-                            const { statuses } = await clickup.getTasks(list.id);
-                            output += `  │  └─ List: ${list.name} (ID: ${list.id})\n`;
-                            output += `  │     Available Statuses: ${statuses.join(', ')}\n`;
-                        }
-                    }
-                    // Get lists directly in space (not in folders)
-                    const spaceLists = allLists.filter(list => list.space &&
-                        list.space.id === space.id &&
-                        !folders.some(folder => folder.lists?.some(fl => fl.id === list.id)));
-                    if (spaceLists.length > 0) {
-                        output += "  ├─ Lists (not in folders):\n";
-                        for (const list of spaceLists) {
-                            const { statuses } = await clickup.getTasks(list.id);
-                            output += `  │  └─ List: ${list.name} (ID: ${list.id})\n`;
-                            output += `  │     Available Statuses: ${statuses.join(', ')}\n`;
-                        }
-                    }
-                    output += "\n";
-                }
-                // Add lists without spaces at the end
-                const listsWithoutSpace = allLists.filter(list => !list.space);
-                if (listsWithoutSpace.length > 0) {
-                    output += "Lists without assigned spaces:\n";
-                    for (const list of listsWithoutSpace) {
-                        const { statuses } = await clickup.getTasks(list.id);
-                        output += `  └─ List: ${list.name} (ID: ${list.id})\n`;
-                        output += `    Available Statuses: ${statuses.join(', ')}\n`;
-                    }
-                }
+                const output = await handleWorkspaceHierarchy(clickup, config.teamId);
                 return {
                     content: [{
                             type: "text",
@@ -447,19 +392,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             case "create_task": {
                 const args = request.params.arguments;
-                let listId = args.listId;
-                if (!listId && args.listName) {
-                    const result = await clickup.findListByNameGlobally(config.teamId, args.listName);
-                    if (!result) {
-                        throw new Error(`List with name "${args.listName}" not found`);
-                    }
-                    listId = result.list.id;
-                }
-                if (!listId) {
-                    throw new Error("Either listId or listName is required");
-                }
-                const { listId: _, listName: __, ...taskData } = args;
-                const task = await clickup.createTask(listId, taskData);
+                const task = await handleCreateTask(clickup, config.teamId, args);
                 return {
                     content: [{
                             type: "text",
@@ -572,19 +505,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 let folderId = args.folderId;
                 if (!folderId && args.folderName) {
-                    let spaceId = args.spaceId;
-                    if (!spaceId && args.spaceName) {
-                        const space = await clickup.findSpaceByName(config.teamId, args.spaceName);
-                        if (!space) {
-                            throw new Error(`Space with name "${args.spaceName}" not found`);
-                        }
-                        spaceId = space.id;
-                    }
-                    if (!spaceId) {
-                        throw new Error("Either spaceId or spaceName must be provided");
+                    const result = await clickup.findFolderByNameGlobally(config.teamId, args.folderName);
+                    if (!result) {
+                        throw new Error(`Folder with name "${args.folderName}" not found`);
                     }
-                    const { spaceId: _, spaceName: ___, ...listData } = args;
-                    const list = await clickup.createListInFolder(spaceId, listData);
+                    folderId = result.folder.id;
+                }
+                if (!folderId) {
+                    throw new Error("Either folderId or folderName is required");
+                }
+                const listData = {
+                    name: args.name,
+                    content: args.content,
+                    status: args.status
+                };
+                try {
+                    const list = await clickup.createListInFolder(folderId, listData);
                     return {
                         content: [{
                                 type: "text",
@@ -592,17 +528,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             }]
                     };
                 }
-                if (!folderId) {
-                    throw new Error("Either folderId or folderName must be provided");
+                catch (error) {
+                    throw new Error(`Failed to create list: ${error.message}`);
                 }
-                const { spaceId: _, spaceName: ___, ...listData } = args;
-                const list = await clickup.createListInFolder(folderId, listData);
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Created list ${list.id}: ${list.name} in folder`
-                        }]
-                };
             }
             case "move_task": {
                 const args = request.params.arguments;
@@ -654,15 +582,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             case "update_task": {
                 const args = request.params.arguments;
-                if (!args.taskId || !args.name || !args.description || !args.status || !args.priority || !args.due_date) {
-                    throw new Error("All arguments are required");
+                if (!args.taskId) {
+                    throw new Error("taskId is required");
                 }
+                const dueDate = args.due_date ? new Date(args.due_date).getTime() : undefined;
                 const task = await clickup.updateTask(args.taskId, {
                     name: args.name,
                     description: args.description,
                     status: args.status,
                     priority: args.priority,
-                    due_date: args.due_date ? new Date(args.due_date).getTime() : undefined
+                    due_date: dueDate
                 });
                 return {
                     content: [{
@@ -671,8 +600,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }]
                 };
             }
+            default:
+                throw new Error("Unknown tool");
         }
-        throw new Error("Unknown tool");
     }
     catch (error) {
         console.error('Error executing tool:', error);
@@ -681,7 +611,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 });
 /**
  * Handler for listing available prompts.
- * Exposes prompts for summarizing/analyzing ClickUp tasks.
  */
 server.setRequestHandler(ListPromptsRequestSchema, async () => {
     return {
@@ -693,33 +622,18 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
             {
                 name: "analyze_task_priorities",
                 description: "Analyze task priorities"
-            },
-            {
-                name: "generate_task_descriptions",
-                description: "Generate detailed descriptions for tasks"
             }
         ]
     };
 });
 /**
  * Handler for getting a specific prompt.
- * Takes a prompt name and returns the prompt content.
  */
 server.setRequestHandler(GetPromptRequestSchema, async (request) => {
     try {
         switch (request.params.name) {
             case "summarize_tasks": {
-                const spaces = await clickup.getSpaces(config.teamId);
-                let output = "Summarized Tasks:\n\n";
-                for (const space of spaces) {
-                    const lists = await clickup.getLists(space.id);
-                    for (const list of lists) {
-                        const { tasks } = await clickup.getTasks(list.id);
-                        for (const task of tasks) {
-                            output += `- ${task.name}: ${task.description}\n`;
-                        }
-                    }
-                }
+                const output = await handleSummarizeTasks(clickup, config.teamId);
                 return {
                     content: [{
                             type: "text",
@@ -728,46 +642,7 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
                 };
             }
             case "analyze_task_priorities": {
-                const spaces = await clickup.getSpaces(config.teamId);
-                const allTasks = [];
-                for (const space of spaces) {
-                    const lists = await clickup.getLists(space.id);
-                    for (const list of lists) {
-                        const { tasks } = await clickup.getTasks(list.id);
-                        allTasks.push(...tasks);
-                    }
-                }
-                const priorities = allTasks.map((task) => task.priority?.priority);
-                const uniquePriorities = [...new Set(priorities.filter(p => p !== undefined))];
-                const priorityCounts = uniquePriorities.map(priority => ({
-                    priority: priority,
-                    count: priorities.filter((p) => p === priority).length
-                }));
-                let output = "Task Priorities Analysis:\n\n";
-                output += "Available Priorities: " + uniquePriorities.join(', ') + "\n\n";
-                output += "Priority Counts:\n";
-                for (const priority of priorityCounts) {
-                    output += `- Priority ${priority.priority}: ${priority.count}\n`;
-                }
-                return {
-                    content: [{
-                            type: "text",
-                            text: output
-                        }]
-                };
-            }
-            case "generate_task_descriptions": {
-                const spaces = await clickup.getSpaces(config.teamId);
-                let output = "Generated Task Descriptions:\n\n";
-                for (const space of spaces) {
-                    const lists = await clickup.getLists(space.id);
-                    for (const list of lists) {
-                        const { tasks } = await clickup.getTasks(list.id);
-                        for (const task of tasks) {
-                            output += `- ${task.name}: ${task.description}\n`;
-                        }
-                    }
-                }
+                const output = await handleAnalyzeTaskPriorities(clickup, config.teamId);
                 return {
                     content: [{
                             type: "text",
@@ -784,6 +659,38 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
         throw error;
     }
 });
-// Start the server
-const transport = new StdioServerTransport();
-transport.start();
+if (process.argv.includes('--stdio')) {
+    console.log('Starting server in stdio mode...');
+    // Set up stdio transport
+    const transport = new StdioServerTransport();
+    // Connect server with better error handling
+    server.connect(transport)
+        .then(() => {
+        console.log('Server connected successfully to stdio transport');
+        // Keep the process alive
+        process.stdin.resume();
+        // Handle process termination
+        process.on('SIGINT', () => {
+            console.log('Received SIGINT. Shutting down...');
+            transport.close();
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            console.log('Received SIGTERM. Shutting down...');
+            transport.close();
+            process.exit(0);
+        });
+    })
+        .catch(error => {
+        console.error('Failed to connect server to transport:', error);
+        process.exit(1);
+    });
+}
+else {
+    console.log('Starting server in standard mode...');
+    // Add your non-stdio server initialization here if needed
+}
+// Prevent unhandled promise rejections from crashing the server
+process.on('unhandledRejection', (error) => {
+    console.error('Unhandled promise rejection:', error);
+});

package/build/utils/resolvers.js

@@ -0,0 +1,48 @@
+export async function resolveListId(clickup, teamId, listId, listName) {
+    if (listId)
+        return listId;
+    if (!listName) {
+        throw new Error("Either listId or listName is required");
+    }
+    const result = await clickup.findListByNameGlobally(teamId, listName);
+    if (!result) {
+        throw new Error(`List with name "${listName}" not found`);
+    }
+    return result.list.id;
+}
+export async function resolveSpaceId(clickup, teamId, spaceId, spaceName) {
+    if (spaceId)
+        return spaceId;
+    if (!spaceName) {
+        throw new Error("Either spaceId or spaceName is required");
+    }
+    const space = await clickup.findSpaceByName(teamId, spaceName);
+    if (!space) {
+        throw new Error(`Space with name "${spaceName}" not found`);
+    }
+    return space.id;
+}
+export async function resolveFolderId(clickup, teamId, folderId, folderName) {
+    if (folderId)
+        return folderId;
+    if (!folderName) {
+        throw new Error("Either folderId or folderName is required");
+    }
+    const result = await clickup.findFolderByNameGlobally(teamId, folderName);
+    if (!result) {
+        throw new Error(`Folder with name "${folderName}" not found`);
+    }
+    return result.folder.id;
+}
+export async function getAllTasks(clickup, teamId) {
+    const spaces = await clickup.getSpaces(teamId);
+    const spacePromises = spaces.map(async (space) => {
+        const lists = await clickup.getLists(space.id);
+        const listPromises = lists.map(list => clickup.getTasks(list.id));
+        const listResults = await Promise.all(listPromises);
+        return listResults.flatMap(result => result.tasks);
+    });
+    const tasksPerSpace = await Promise.all(spacePromises);
+    const allTasks = tasksPerSpace.flat();
+    return { tasks: allTasks, spaces };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taazkareem/clickup-mcp-server",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "ClickUp MCP Server - Integrate ClickUp tasks with AI through Model Context Protocol",
   "type": "module",
   "main": "build/index.js",
@@ -15,6 +15,7 @@
   "scripts": {
     "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
     "start": "node build/index.js",
+    "serve": "node build/index.js --stdio",
     "dev": "tsc -w",
     "prepare": "npm run build",
     "prepublishOnly": "npm test",