@taazkareem/clickup-mcp-server 0.4.25 → 0.4.27

package/build/index.js

@@ -7,15 +7,14 @@
  *
  * @module clickup-mcp-server
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.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";
-import { handleWorkspaceHierarchy, handleCreateTask, handleCreateBulkTasks, handleCreateList, handleCreateFolder, handleCreateListInFolder, handleMoveTask, handleDuplicateTask, handleUpdateTask } from "./handlers/tools.js";
+import { handleWorkspaceHierarchy, handleCreateTask, handleCreateBulkTasks, handleCreateList, handleCreateFolder, handleCreateListInFolder } from "./handlers/tools.js";
 import { handleSummarizeTasks, handleAnalyzeTaskPriorities } from "./handlers/prompts.js";
-import { getAllTasks } from "./utils/resolvers.js";
 import { logError, logInfo, logDebug } from "./utils/logger.js";
+import { z } from 'zod';
 // Set up global error handlers
 process.on('uncaughtException', (error) => {
     logError('server.uncaught', error);
@@ -30,10 +29,7 @@ logInfo('config', {
     clickupApiKey: config.clickupApiKey ? '***' : 'missing',
     teamId: config.teamId || 'missing'
 });
-/**
- * Initialize ClickUp service singleton
- * This must be done before any other ClickUp operations
- */
+// Initialize ClickUp service singleton
 let clickup;
 try {
     logDebug('clickup', { status: 'initializing' });
@@ -44,481 +40,169 @@ catch (error) {
     logError('clickup.initialization', error);
     process.exit(1);
 }
-/**
- * Create and configure the MCP server instance
- * Sets up capabilities, tools, and error handling
- */
+// Create and configure the MCP server instance
 logDebug('mcp', { status: 'creating' });
-// Define server capabilities
-const serverCapabilities = {
-    tools: {
-        workspace_hierarchy: {
-            description: "List complete hierarchy of the ClickUp workspace",
-            inputSchema: {
-                type: "object",
-                properties: {},
-                required: []
-            }
-        },
-        create_task: {
-            description: "Create a new task in ClickUp",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    listId: {
-                        type: "string",
-                        description: "ID of the list to create the task in (optional if listName is provided)"
-                    },
-                    listName: {
-                        type: "string",
-                        description: "Name of the list to create the task in (optional if listId is provided)"
-                    },
-                    name: {
-                        type: "string",
-                        description: "Name of the task"
-                    },
-                    description: {
-                        type: "string",
-                        description: "Description of the task"
-                    },
-                    status: {
-                        type: "string",
-                        description: "Status of the task"
-                    },
-                    priority: {
-                        type: "number",
-                        description: "Priority of the task (1-4)"
-                    },
-                    dueDate: {
-                        type: "string",
-                        description: "Due date of the task (ISO string)"
-                    }
-                },
-                required: ["name"]
-            }
-        },
-        create_bulk_tasks: {
-            description: "Create multiple tasks simultaneously in a list",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    listId: {
-                        type: "string",
-                        description: "ID of the list to create tasks in (optional if listName is provided)"
-                    },
-                    listName: {
-                        type: "string",
-                        description: "Name of the list to create tasks in (optional if listId is provided)"
-                    },
-                    tasks: {
-                        type: "array",
-                        description: "Array of tasks to create",
-                        items: {
-                            type: "object",
-                            properties: {
-                                name: {
-                                    type: "string",
-                                    description: "Name of the task"
-                                },
-                                description: {
-                                    type: "string",
-                                    description: "Description of the task"
-                                },
-                                status: {
-                                    type: "string",
-                                    description: "Status of the task"
-                                },
-                                priority: {
-                                    type: "number",
-                                    description: "Priority of the task (1-4)"
-                                },
-                                dueDate: {
-                                    type: "string",
-                                    description: "Due date of the task (ISO string)"
-                                }
-                            },
-                            required: ["name"]
-                        }
-                    }
-                },
-                required: ["tasks"]
-            }
-        },
-        create_list: {
-            description: "Create a new list in a space",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    spaceId: {
-                        type: "string",
-                        description: "ID of the space (optional if spaceName is provided)"
-                    },
-                    spaceName: {
-                        type: "string",
-                        description: "Name of the space (optional if spaceId is provided)"
-                    },
-                    name: {
-                        type: "string",
-                        description: "Name of the list"
-                    },
-                    content: {
-                        type: "string",
-                        description: "List description"
-                    }
-                },
-                required: ["name"]
-            }
-        },
-        create_folder: {
-            description: "Create a new folder in a space",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    spaceId: {
-                        type: "string",
-                        description: "ID of the space (optional if spaceName is provided)"
-                    },
-                    spaceName: {
-                        type: "string",
-                        description: "Name of the space (optional if spaceId is provided)"
-                    },
-                    name: {
-                        type: "string",
-                        description: "Name of the folder"
-                    },
-                    override_statuses: {
-                        type: "boolean",
-                        description: "Whether to override space statuses"
-                    }
-                },
-                required: ["name"]
-            }
-        },
-        create_list_in_folder: {
-            description: "Create a new list within a folder",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    folderId: {
-                        type: "string",
-                        description: "ID of the folder (optional if using folderName)"
-                    },
-                    folderName: {
-                        type: "string",
-                        description: "Name of the folder"
-                    },
-                    spaceId: {
-                        type: "string",
-                        description: "ID of the space (required if using folderName)"
-                    },
-                    spaceName: {
-                        type: "string",
-                        description: "Name of the space (alternative to spaceId)"
-                    },
-                    name: {
-                        type: "string",
-                        description: "Name of the list"
-                    },
-                    content: {
-                        type: "string",
-                        description: "List description"
-                    }
-                },
-                required: ["name"]
-            }
-        },
-        move_task: {
-            description: "Move a task to a different list",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    taskId: {
-                        type: "string",
-                        description: "ID of the task to move"
-                    },
-                    listId: {
-                        type: "string",
-                        description: "ID of destination list (optional if listName is provided)"
-                    },
-                    listName: {
-                        type: "string",
-                        description: "Name of destination list (optional if listId is provided)"
-                    }
-                },
-                required: ["taskId"]
-            }
-        },
-        duplicate_task: {
-            description: "Create a copy of a task in a specified list",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    taskId: {
-                        type: "string",
-                        description: "ID of the task to duplicate"
-                    },
-                    listId: {
-                        type: "string",
-                        description: "ID of destination list (optional if listName is provided)"
-                    },
-                    listName: {
-                        type: "string",
-                        description: "Name of destination list (optional if listId is provided)"
-                    }
-                },
-                required: ["taskId"]
-            }
-        },
-        update_task: {
-            description: "Update an existing task",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    taskId: {
-                        type: "string",
-                        description: "ID of the task to update"
-                    },
-                    name: {
-                        type: "string",
-                        description: "New task name"
-                    },
-                    description: {
-                        type: "string",
-                        description: "New description"
-                    },
-                    status: {
-                        type: "string",
-                        description: "New status"
-                    },
-                    priority: {
-                        type: "number",
-                        description: "New priority level (1-4)"
-                    },
-                    dueDate: {
-                        type: "string",
-                        description: "New due date (ISO string)"
-                    }
-                },
-                required: ["taskId"]
-            }
-        }
-    },
-    prompts: {
-        summarize_tasks: {
-            description: "Summarize all ClickUp tasks"
-        },
-        analyze_task_priorities: {
-            description: "Analyze task priorities"
-        }
-    },
-    resources: {
-        list: true,
-        read: true
-    }
-};
-// Create server instance with capabilities
-const server = new Server({
+const mcpServer = new McpServer({
     name: "clickup-mcp-server",
-    version: "0.4.24",
+    version: "0.4.25",
     capabilities: {
-        tools: {
-            enabled: true,
-            call: true,
-            list: true,
-            schemas: serverCapabilities.tools
-        },
-        prompts: {
-            enabled: true,
-            list: true,
-            get: true,
-            schemas: serverCapabilities.prompts
-        },
-        resources: {
-            enabled: true,
-            list: true,
-            read: true
-        }
-    },
-    errorHandler: (error) => {
-        logError('mcp', error);
+        tools: true,
+        prompts: true,
+        resources: true
     }
 });
-// Server startup logic
-if (process.argv.includes('--stdio')) {
-    logInfo('server', { status: 'stdio.starting' });
-    // Register handlers BEFORE connection
-    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}`);
+// Tool schemas as raw shapes
+const workspaceHierarchySchema = {
+    teamId: z.string().optional()
+};
+const taskSchema = {
+    name: z.string(),
+    description: z.string().optional(),
+    status: z.string().optional(),
+    priority: z.number().optional(),
+    dueDate: z.string().optional(),
+    listId: z.string().optional(),
+    listName: z.string().optional()
+};
+const bulkTasksSchema = {
+    tasks: z.array(z.object(taskSchema)),
+    listId: z.string().optional(),
+    listName: z.string().optional()
+};
+const listSchema = {
+    name: z.string(),
+    spaceId: z.string().optional(),
+    spaceName: z.string().optional(),
+    content: z.string().optional()
+};
+const folderSchema = {
+    name: z.string(),
+    spaceId: z.string().optional(),
+    spaceName: z.string().optional(),
+    override_statuses: z.boolean().optional()
+};
+const listInFolderSchema = {
+    name: z.string(),
+    folderId: z.string().optional(),
+    folderName: z.string().optional(),
+    spaceId: z.string().optional(),
+    spaceName: z.string().optional(),
+    content: z.string().optional()
+};
+// Register tools with proper schemas
+mcpServer.tool('workspace_hierarchy', 'List complete hierarchy of the ClickUp workspace', workspaceHierarchySchema, async (args) => {
+    const result = await handleWorkspaceHierarchy(clickup, config.teamId);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }]
+    };
+});
+mcpServer.tool('create_task', 'Create a new task in ClickUp', taskSchema, async (args) => {
+    const result = await handleCreateTask(clickup, config.teamId, args);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }]
+    };
+});
+mcpServer.tool('create_bulk_tasks', 'Create multiple tasks simultaneously in a list', bulkTasksSchema, async (args) => {
+    const result = await handleCreateBulkTasks(clickup, config.teamId, args);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }]
+    };
+});
+mcpServer.tool('create_list', 'Create a new list in a space', listSchema, async (args) => {
+    const result = await handleCreateList(clickup, config.teamId, args);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }]
+    };
+});
+mcpServer.tool('create_folder', 'Create a new folder in a space', folderSchema, async (args) => {
+    const result = await handleCreateFolder(clickup, config.teamId, args);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }]
+    };
+});
+mcpServer.tool('create_list_in_folder', 'Create a new list within a folder', listInFolderSchema, async (args) => {
+    const result = await handleCreateListInFolder(clickup, config.teamId, args);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }]
+    };
+});
+// Register prompts with descriptions
+mcpServer.prompt('summarize_tasks', 'Provide a comprehensive summary of tasks', async () => {
+    const summary = await handleSummarizeTasks(clickup, config.teamId);
+    return {
+        messages: [{
+                role: 'assistant',
+                content: {
+                    type: 'text',
+                    text: summary
                 }
-            }
-            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");
+            }],
+        description: 'Task Summary'
+    };
+});
+mcpServer.prompt('analyze_task_priorities', 'Analyze task priorities and provide recommendations', async () => {
+    const analysis = await handleAnalyzeTaskPriorities(clickup, config.teamId);
+    return {
+        messages: [{
+                role: 'assistant',
+                content: {
+                    type: 'text',
+                    text: analysis
                 }
-            }
-            catch (error) {
-                logError('prompt', error);
-                throw error;
-            }
-        });
-        logInfo('server', { status: 'handlers.registered' });
-    }
-    catch (error) {
-        logError('server.handlers', error);
-        process.exit(1);
+            }],
+        description: 'Priority Analysis'
+    };
+});
+// TODO: Implement resource handler properly after consulting MCP SDK documentation
+// Resource handler temporarily disabled due to type issues
+/*
+mcpServer.resource(
+  'clickup',
+  'clickup://task/{id}',
+  async (uri: URL) => {
+    try {
+      const taskId = uri.pathname.split('/').pop() || '';
+      const task = await clickup.getTask(taskId);
+      return {
+        uri: uri.toString(),
+        mimeType: "application/json",
+        text: JSON.stringify(task, null, 2),
+        tags: []
+      };
+    } catch (error) {
+      logError('resources.read', error);
+      throw error;
     }
-    // Set up stdio transport and connect first
+  }
+);
+*/
+// Server startup logic
+if (process.argv.includes('--stdio')) {
+    logInfo('server', { status: 'stdio.starting' });
+    // Create stdio transport
     const transport = new StdioServerTransport();
     // Connect server with better error handling
-    server.connect(transport)
-        .then(async () => {
+    mcpServer.server.connect(transport)
+        .then(() => {
         logInfo('server', { status: 'connected' });
-        // Send initial handshake message with more details
-        const capabilities = {
-            tools: server.capabilities?.tools || {},
-            prompts: server.capabilities?.prompts || {},
-            resources: {
-                list: true,
-                read: true
-            }
-        };
-        logInfo('mcp', { status: 'handshake.preparing' });
-        logInfo('mcp', {
-            status: 'handshake',
-            name: "clickup-mcp-server",
-            version: "0.4.19",
-            hasTools: Object.keys(capabilities.tools).length > 0,
-            hasPrompts: Object.keys(capabilities.prompts).length > 0
-        });
         logInfo('server', { status: 'ready' });
         // Keep the process alive
         process.stdin.resume();
@@ -539,10 +223,7 @@ if (process.argv.includes('--stdio')) {
         process.exit(1);
     });
 }
-else {
-    logInfo('server', { status: 'standard.starting' });
-    // Add your non-stdio server initialization here if needed
-}
+// Note: Non-stdio initialization removed as it was unused
 // Prevent unhandled promise rejections from crashing the server
 process.on('unhandledRejection', (error) => {
     logError('server.unhandled', error);

package/package.json

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