@taazkareem/clickup-mcp-server 0.4.19 → 0.4.21

package/build/index.js

@@ -319,202 +319,181 @@ const serverCapabilities = {
 // Create server instance with capabilities
 const server = new Server({
     name: "clickup-mcp-server",
-    version: "0.4.18",
+    version: "0.4.20",
     transport: new StdioServerTransport(),
-    capabilities: serverCapabilities,
+    capabilities: {
+        tools: {
+            enabled: true,
+            tools: serverCapabilities.tools
+        },
+        prompts: serverCapabilities.prompts,
+        resources: serverCapabilities.resources
+    },
     errorHandler: (error) => {
         logError('mcp', error);
     }
 });
-/**
- * Register handlers for MCP tool requests
- * Each tool is mapped to its corresponding handler function
- */
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    try {
-        logDebug('tool.request', { name: request.params.name });
-        switch (request.params.name) {
-            case "workspace_hierarchy": {
-                return await handleWorkspaceHierarchy(clickup, config.teamId);
-            }
-            case "create_task": {
-                const args = request.params.arguments;
-                return await handleCreateTask(clickup, config.teamId, args);
-            }
-            case "create_bulk_tasks": {
-                const args = request.params.arguments;
-                return await handleCreateBulkTasks(clickup, config.teamId, args);
-            }
-            case "create_list": {
-                const args = request.params.arguments;
-                return await handleCreateList(clickup, config.teamId, args);
-            }
-            case "create_folder": {
-                const args = request.params.arguments;
-                return await handleCreateFolder(clickup, config.teamId, args);
-            }
-            case "create_list_in_folder": {
-                const args = request.params.arguments;
-                return await handleCreateListInFolder(clickup, config.teamId, args);
-            }
-            case "move_task": {
-                const args = request.params.arguments;
-                return await handleMoveTask(clickup, config.teamId, args);
-            }
-            case "duplicate_task": {
-                const args = request.params.arguments;
-                return await handleDuplicateTask(clickup, config.teamId, args);
-            }
-            case "update_task": {
-                const args = request.params.arguments;
-                return await handleUpdateTask(clickup, config.teamId, args);
-            }
-            default:
-                throw new Error(`Unknown tool: ${request.params.name}`);
-        }
-    }
-    catch (error) {
-        logError(`tool.${request.params.name}`, error);
-        throw error;
-    }
-});
-/**
- * Initialize and start the server
- * Connects to the transport and begins listening for requests
- */
-try {
-    logInfo('mcp', { status: 'connecting' });
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    logInfo('mcp', { status: 'connected' });
-}
-catch (error) {
-    logError('mcp.connection', error);
-    process.exit(1);
-}
-/**
- * Handler for listing available ClickUp tasks as resources
- * Returns a list of all tasks across all spaces with their metadata
- */
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    logDebug('resources', { action: 'listing' });
-    try {
-        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) {
-        logError('resources.list', error);
-        throw error;
-    }
-});
-/**
- * Handler for reading individual ClickUp task contents
- * Returns detailed information about a specific task
- */
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    try {
-        const url = new URL(request.params.uri);
-        const taskId = url.pathname.replace(/^\/task\//, '');
-        logDebug('resources.read', { taskId });
-        const task = await clickup.getTask(taskId);
-        return {
-            contents: [{
-                    uri: request.params.uri,
-                    mimeType: "application/json",
-                    text: JSON.stringify(task, null, 2),
-                    tags: []
-                }]
-        };
-    }
-    catch (error) {
-        logError('resources.read', error);
-        throw error;
-    }
-});
-/**
- * Handler for listing available tools
- * Returns metadata about all registered tools
- */
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    logDebug('tools', { action: 'listing' });
-    const toolCapabilities = server.capabilities?.tools || {};
-    const tools = Object.entries(toolCapabilities).map(([name, tool]) => ({
-        name,
-        description: tool.description,
-        inputSchema: tool.inputSchema
-    }));
-    logDebug('tools', { count: tools.length });
-    return { tools };
-});
-/**
- * Handler for listing available prompts
- * Returns metadata about all registered prompts
- */
-server.setRequestHandler(ListPromptsRequestSchema, async () => {
-    return {
-        prompts: [
-            {
-                name: "summarize_tasks",
-                description: "Summarize all ClickUp tasks"
-            },
-            {
-                name: "analyze_task_priorities",
-                description: "Analyze task priorities"
-            }
-        ]
-    };
-});
-/**
- * Handler for executing specific prompts
- * Maps prompt names to their corresponding handler functions
- */
-server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    try {
-        switch (request.params.name) {
-            case "summarize_tasks": {
-                const output = await handleSummarizeTasks(clickup, config.teamId);
-                return {
-                    content: [{
-                            type: "text",
-                            text: output
-                        }]
-                };
-            }
-            case "analyze_task_priorities": {
-                const output = await handleAnalyzeTaskPriorities(clickup, config.teamId);
-                return {
-                    content: [{
-                            type: "text",
-                            text: output
-                        }]
-                };
-            }
-            default:
-                throw new Error("Prompt not found");
-        }
-    }
-    catch (error) {
-        logError('prompt', error);
-        throw error;
-    }
-});
 // Server startup logic
 if (process.argv.includes('--stdio')) {
     logInfo('server', { status: 'stdio.starting' });
-    // Set up stdio transport
+    // Set up stdio transport and connect first
     const transport = new StdioServerTransport();
     // Connect server with better error handling
     server.connect(transport)
-        .then(() => {
+        .then(async () => {
         logInfo('server', { status: 'connected' });
+        // Wait for capabilities to be registered
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Register handlers AFTER connection and capability registration
+        try {
+            server.setRequestHandler(CallToolRequestSchema, async (request) => {
+                try {
+                    logDebug('tool.request', { name: request.params.name });
+                    switch (request.params.name) {
+                        case "workspace_hierarchy": {
+                            return await handleWorkspaceHierarchy(clickup, config.teamId);
+                        }
+                        case "create_task": {
+                            const args = request.params.arguments;
+                            return await handleCreateTask(clickup, config.teamId, args);
+                        }
+                        case "create_bulk_tasks": {
+                            const args = request.params.arguments;
+                            return await handleCreateBulkTasks(clickup, config.teamId, args);
+                        }
+                        case "create_list": {
+                            const args = request.params.arguments;
+                            return await handleCreateList(clickup, config.teamId, args);
+                        }
+                        case "create_folder": {
+                            const args = request.params.arguments;
+                            return await handleCreateFolder(clickup, config.teamId, args);
+                        }
+                        case "create_list_in_folder": {
+                            const args = request.params.arguments;
+                            return await handleCreateListInFolder(clickup, config.teamId, args);
+                        }
+                        case "move_task": {
+                            const args = request.params.arguments;
+                            return await handleMoveTask(clickup, config.teamId, args);
+                        }
+                        case "duplicate_task": {
+                            const args = request.params.arguments;
+                            return await handleDuplicateTask(clickup, config.teamId, args);
+                        }
+                        case "update_task": {
+                            const args = request.params.arguments;
+                            return await handleUpdateTask(clickup, config.teamId, args);
+                        }
+                        default:
+                            throw new Error(`Unknown tool: ${request.params.name}`);
+                    }
+                }
+                catch (error) {
+                    logError(`tool.${request.params.name}`, error);
+                    throw error;
+                }
+            });
+            server.setRequestHandler(ListResourcesRequestSchema, async () => {
+                logDebug('resources', { action: 'listing' });
+                try {
+                    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) {
+                    logError('resources.list', error);
+                    throw error;
+                }
+            });
+            server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+                try {
+                    const url = new URL(request.params.uri);
+                    const taskId = url.pathname.replace(/^\/task\//, '');
+                    logDebug('resources.read', { taskId });
+                    const task = await clickup.getTask(taskId);
+                    return {
+                        contents: [{
+                                uri: request.params.uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify(task, null, 2),
+                                tags: []
+                            }]
+                    };
+                }
+                catch (error) {
+                    logError('resources.read', error);
+                    throw error;
+                }
+            });
+            server.setRequestHandler(ListToolsRequestSchema, async () => {
+                logDebug('tools', { action: 'listing' });
+                const toolCapabilities = server.capabilities?.tools || {};
+                const tools = Object.entries(toolCapabilities).map(([name, tool]) => ({
+                    name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema
+                }));
+                logDebug('tools', { count: tools.length });
+                return { tools };
+            });
+            server.setRequestHandler(ListPromptsRequestSchema, async () => {
+                return {
+                    prompts: [
+                        {
+                            name: "summarize_tasks",
+                            description: "Summarize all ClickUp tasks"
+                        },
+                        {
+                            name: "analyze_task_priorities",
+                            description: "Analyze task priorities"
+                        }
+                    ]
+                };
+            });
+            server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+                try {
+                    switch (request.params.name) {
+                        case "summarize_tasks": {
+                            const output = await handleSummarizeTasks(clickup, config.teamId);
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: output
+                                    }]
+                            };
+                        }
+                        case "analyze_task_priorities": {
+                            const output = await handleAnalyzeTaskPriorities(clickup, config.teamId);
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: output
+                                    }]
+                            };
+                        }
+                        default:
+                            throw new Error("Prompt not found");
+                    }
+                }
+                catch (error) {
+                    logError('prompt', error);
+                    throw error;
+                }
+            });
+            logInfo('server', { status: 'handlers.registered' });
+        }
+        catch (error) {
+            logError('server.handlers', error);
+            process.exit(1);
+        }
         // Send initial handshake message with more details
         const capabilities = {
             tools: server.capabilities?.tools || {},
@@ -528,7 +507,7 @@ if (process.argv.includes('--stdio')) {
         logInfo('mcp', {
             status: 'handshake',
             name: "clickup-mcp-server",
-            version: "0.4.17", // Match package.json version
+            version: "0.4.19",
             hasTools: Object.keys(capabilities.tools).length > 0,
             hasPrompts: Object.keys(capabilities.prompts).length > 0
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taazkareem/clickup-mcp-server",
-  "version": "0.4.19",
+  "version": "0.4.21",
   "description": "ClickUp MCP Server - Integrate ClickUp tasks with AI through Model Context Protocol",
   "type": "module",
   "main": "./build/index.js",