@taazkareem/clickup-mcp-server 0.4.68 → 0.4.69

package/README.md

@@ -3,7 +3,7 @@
 # MCP Server
 A Model Context Protocol (MCP) server for integrating ClickUp tasks with AI applications. This server allows AI agents to interact with ClickUp tasks, spaces, lists, and folders through a standardized protocol.
 
-> 🚧 **Status Update:** -The code refactoring has been completed. -Enhanced due date functionality now supports relative time expressions like "2 hours from now" with proper time display in ClickUp. -Server has been listed on Smithery, Glama, and Pulse MCP
+> 🚧 **Status Update:** -Improved task name matching and fixed workspace hierarchy display
 
 <a href="https://glama.ai/mcp/servers/iwjvs2zy63">
   <img width="380" height="200" src="https://glama.ai/mcp/servers/iwjvs2zy63/badge" alt="ClickUp Server MCP server" />
@@ -27,11 +27,11 @@ npx -y @taazkareem/clickup-mcp-server@latest \
 5. Use Natural Language to interact with your ClickUp Workspace!
 
 
-## Smithery Installation (recommended)
+## Smithery Installation
 
 [![smithery badge](https://smithery.ai/badge/@TaazKareem/clickup-mcp-server)](https://smithery.ai/server/@TaazKareem/clickup-mcp-server)
 
-The server is hosted on Smithery. There, you can preview the available tools or copy the commands to run on various clients.
+The server is also hosted on Smithery. There, you can preview the available tools or copy the commands to run on your specific client app.
 
 ## Features
 
@@ -83,7 +83,7 @@ The server is hosted on Smithery. There, you can preview the available tools or
 See [full documentation](docs/api-reference.md) for optional parameters and advanced usage.
 
 ## Available Prompts
-Not yet implemented (or needed. For now, you can send a follow up prompt after tool result.)
+Not yet implemented (or needed) For now, you can send a follow up prompt after the tool result.
 
 | Prompt | Purpose | Features |
 |--------|---------|----------|

package/build/index.js

@@ -38,19 +38,68 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { configureServer, server } from "./server.js";
 import { clickUpServices } from "./services/shared.js";
 import { initializeWorkspaceTool } from "./tools/workspace.js";
+import { info, error, warn } from "./logger.js";
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * Check if another instance of the server is already running
+ * @returns Boolean indicating if this is the only instance
+ */
+async function checkSingleInstance() {
+    try {
+        const { stdout } = await execAsync(`ps aux | grep "node.*clickup-mcp-server" | grep -v grep | wc -l`);
+        const instanceCount = parseInt(stdout.trim(), 10);
+        // If there's more than one instance (including this one), warn and exit
+        if (instanceCount > 1) {
+            error(`Multiple server instances detected (${instanceCount}). This may cause issues.`);
+            info("Use 'pkill -9 -f clickup-mcp-server' to kill all instances before starting a new one.");
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        error("Failed to check for other running instances", err);
+        // Continue execution even if check fails
+        return true;
+    }
+}
 /**
  * Application entry point that configures and starts the MCP server.
  */
 async function main() {
-    // Initialize tools with services
-    initializeWorkspaceTool(clickUpServices);
-    // Configure the server with all handlers
-    await configureServer();
-    // Connect using stdio transport
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+    try {
+        info("Starting ClickUp MCP Server...");
+        // Check if we're the only instance
+        const isSingleInstance = await checkSingleInstance();
+        if (!isSingleInstance) {
+            warn("Continuing startup despite multiple instances detected");
+        }
+        // Log essential information about the environment
+        info("Server environment", {
+            pid: process.pid,
+            node: process.version,
+            os: process.platform,
+            arch: process.arch
+        });
+        // Initialize tools with services
+        info("Initializing workspace tools");
+        initializeWorkspaceTool(clickUpServices);
+        // Configure the server with all handlers
+        info("Configuring server request handlers");
+        await configureServer();
+        // Connect using stdio transport
+        info("Connecting to MCP stdio transport");
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        info("Server startup complete - ready to handle requests");
+    }
+    catch (err) {
+        error("Error during server startup", err);
+        process.exit(1);
+    }
 }
-main().catch((error) => {
-    console.error("Server error:", error);
+main().catch((err) => {
+    error("Unhandled server error", err);
     process.exit(1);
 });

package/build/logger.js

@@ -0,0 +1,166 @@
+/**
+ * Logger module for MCP Server
+ *
+ * This module provides logging functionality for the server,
+ * writing logs to both the console and a log file in the build folder.
+ */
+import { createWriteStream } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Get the directory name of the current module
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Current process ID for logging
+const pid = process.pid;
+// Create a write stream for logging - use a fixed filename in the build directory
+const logFileName = 'server.log';
+const logStream = createWriteStream(join(__dirname, logFileName), { flags: 'w' });
+console.error(`Logging to ${join(__dirname, logFileName)}`);
+// Log levels with numeric values for filtering
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["TRACE"] = 0] = "TRACE";
+    LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["WARN"] = 3] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+// Fixed log level - always use TRACE as the minimum level for complete logging
+const configuredLevel = LogLevel.TRACE;
+/**
+ * Check if a log level is enabled based on the configured level
+ * @param level The log level to check
+ * @returns True if the level should be logged
+ */
+export function isLevelEnabled(level) {
+    return level >= configuredLevel;
+}
+/**
+ * Log function that writes to both console and file
+ * @param level Log level (trace, debug, info, warn, error)
+ * @param message Message to log
+ * @param data Optional data to include in log
+ */
+export function log(level, message, data) {
+    const levelEnum = level === 'trace' ? LogLevel.TRACE
+        : level === 'debug' ? LogLevel.DEBUG
+            : level === 'info' ? LogLevel.INFO
+                : level === 'warn' ? LogLevel.WARN
+                    : LogLevel.ERROR;
+    // Skip if level is below configured level
+    if (!isLevelEnabled(levelEnum)) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const logMessage = `[${timestamp}] [PID:${pid}] ${level.toUpperCase()}: ${message}${data ? '\n' + JSON.stringify(data, null, 2) : ''}`;
+    // When using stdio transport, log to stderr which is captured by host application
+    console.error(logMessage);
+    // Write to file
+    logStream.write(logMessage + '\n');
+}
+/**
+ * Shorthand for trace level logs
+ * @param message Message to log
+ * @param data Optional data to include in log
+ */
+export function trace(message, data) {
+    log('trace', message, data);
+}
+/**
+ * Shorthand for debug level logs
+ * @param message Message to log
+ * @param data Optional data to include in log
+ */
+export function debug(message, data) {
+    log('debug', message, data);
+}
+/**
+ * Shorthand for info level logs
+ * @param message Message to log
+ * @param data Optional data to include in log
+ */
+export function info(message, data) {
+    log('info', message, data);
+}
+/**
+ * Shorthand for warn level logs
+ * @param message Message to log
+ * @param data Optional data to include in log
+ */
+export function warn(message, data) {
+    log('warn', message, data);
+}
+/**
+ * Shorthand for error level logs
+ * @param message Message to log
+ * @param data Optional data to include in log
+ */
+export function error(message, data) {
+    log('error', message, data);
+}
+/**
+ * Logger class for creating context-specific loggers
+ */
+export class Logger {
+    /**
+     * Create a new logger with context
+     * @param context The context to prepend to log messages
+     */
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * Check if a log level is enabled for this logger
+     * @param level The level to check
+     * @returns True if logging at this level is enabled
+     */
+    isLevelEnabled(level) {
+        return isLevelEnabled(level);
+    }
+    /**
+     * Log at trace level
+     * @param message Message to log
+     * @param data Optional data to include in log
+     */
+    trace(message, data) {
+        log('trace', `[${this.context}] ${message}`, data);
+    }
+    /**
+     * Log at debug level
+     * @param message Message to log
+     * @param data Optional data to include in log
+     */
+    debug(message, data) {
+        log('debug', `[${this.context}] ${message}`, data);
+    }
+    /**
+     * Log at info level
+     * @param message Message to log
+     * @param data Optional data to include in log
+     */
+    info(message, data) {
+        log('info', `[${this.context}] ${message}`, data);
+    }
+    /**
+     * Log at warn level
+     * @param message Message to log
+     * @param data Optional data to include in log
+     */
+    warn(message, data) {
+        log('warn', `[${this.context}] ${message}`, data);
+    }
+    /**
+     * Log at error level
+     * @param message Message to log
+     * @param data Optional data to include in log
+     */
+    error(message, data) {
+        log('error', `[${this.context}] ${message}`, data);
+    }
+}
+// Handle SIGTERM for clean shutdown
+process.on('SIGTERM', () => {
+    log('info', 'Received SIGTERM signal, shutting down...');
+    logStream.end(() => {
+        process.exit(0);
+    });
+});

package/build/server-state.js

@@ -0,0 +1,93 @@
+/**
+ * Server State Management Module
+ *
+ * This module provides shared state management for the MCP server,
+ * particularly for controlling shutdown behavior and tracking busy states.
+ */
+// State variables
+let serverBusyState = false; // Tracks if server is doing critical work
+let gracePeriodActive = false; // Tracks if we're in post-initialization grace period
+let gracePeriodTimer = null;
+export const GRACE_PERIOD_MS = 10000; // 10 second grace period after startup
+/**
+ * Logging helper that avoids circular dependency
+ */
+function safeLog(level, message, data) {
+    // Use console as a fallback to avoid circular dependency with logger
+    const timestamp = new Date().toISOString();
+    if (level === 'error') {
+        console.error(`[${timestamp}] ${level.toUpperCase()}: ${message}`, data || '');
+    }
+    else if (level === 'debug' && process.env.DEBUG) {
+        console.debug(`[${timestamp}] ${level.toUpperCase()}: ${message}`, data || '');
+    }
+    else if (level !== 'debug') {
+        console.log(`[${timestamp}] ${level.toUpperCase()}: ${message}`, data || '');
+    }
+}
+/**
+ * Set the server as busy doing critical work that shouldn't be interrupted
+ * @param busy Whether the server is currently busy with critical operations
+ */
+export function setServerBusy(busy) {
+    serverBusyState = busy;
+    safeLog('debug', `Server busy state set to: ${busy}`);
+}
+/**
+ * Start grace period after initialization to prevent immediate shutdown
+ */
+export function startGracePeriod() {
+    gracePeriodActive = true;
+    safeLog('debug', `Starting ${GRACE_PERIOD_MS}ms grace period to prevent premature shutdown`);
+    if (gracePeriodTimer) {
+        clearTimeout(gracePeriodTimer);
+    }
+    gracePeriodTimer = setTimeout(() => {
+        gracePeriodActive = false;
+        safeLog('debug', 'Grace period ended, server will now respond to shutdown signals');
+        gracePeriodTimer = null;
+    }, GRACE_PERIOD_MS);
+}
+/**
+ * Cancel the grace period if needed
+ */
+export function cancelGracePeriod() {
+    if (gracePeriodTimer) {
+        clearTimeout(gracePeriodTimer);
+        gracePeriodTimer = null;
+    }
+    gracePeriodActive = false;
+    safeLog('debug', 'Grace period canceled, server will now respond to shutdown signals');
+}
+/**
+ * Check if the server should ignore shutdown signals
+ * @returns true if shutdown signals should be ignored
+ */
+export function shouldIgnoreShutdown() {
+    // Ignore shutdown if explicitly configured via environment variable
+    if (process.env.FORCE_KEEP_ALIVE === 'true') {
+        return true;
+    }
+    // Ignore shutdown during the grace period after startup
+    if (gracePeriodActive) {
+        return true;
+    }
+    // Ignore shutdown if the server is doing critical work
+    if (serverBusyState) {
+        return true;
+    }
+    // Otherwise, allow normal shutdown
+    return false;
+}
+/**
+ * Check if grace period is currently active
+ */
+export function isGracePeriodActive() {
+    return gracePeriodActive;
+}
+/**
+ * Check if server is currently in busy state
+ */
+export function isServerBusy() {
+    return serverBusyState;
+}

package/build/server.js

@@ -1,18 +1,15 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { createClickUpServices } from "./services/clickup/index.js";
-import config from "./config.js";
 import { workspaceHierarchyTool, handleGetWorkspaceHierarchy } from "./tools/workspace.js";
-import { createTaskTool, handleCreateTask, updateTaskTool, handleUpdateTask, moveTaskTool, handleMoveTask, duplicateTaskTool, handleDuplicateTask, getTaskTool, handleGetTask, getTasksTool, handleGetTasks, deleteTaskTool, handleDeleteTask, createBulkTasksTool, handleCreateBulkTasks, updateBulkTasksTool, handleUpdateBulkTasks, moveBulkTasksTool, handleMoveBulkTasks, deleteBulkTasksTool, handleDeleteBulkTasks } from "./tools/task.js";
+import { createTaskTool, handleCreateTask, updateTaskTool, handleUpdateTask, moveTaskTool, handleMoveTask, duplicateTaskTool, handleDuplicateTask, getTaskTool, getTasksTool, handleGetTasks, deleteTaskTool, handleDeleteTask, createBulkTasksTool, handleCreateBulkTasks, updateBulkTasksTool, handleUpdateBulkTasks, moveBulkTasksTool, handleMoveBulkTasks, deleteBulkTasksTool, handleDeleteBulkTasks, getTaskCommentsTool, handleGetTaskComments } from "./tools/task.js";
 import { createListTool, handleCreateList, createListInFolderTool, handleCreateListInFolder, getListTool, handleGetList, updateListTool, handleUpdateList, deleteListTool, handleDeleteList } from "./tools/list.js";
 import { createFolderTool, handleCreateFolder, getFolderTool, handleGetFolder, updateFolderTool, handleUpdateFolder, deleteFolderTool, handleDeleteFolder } from "./tools/folder.js";
-// Initialize ClickUp services
-const services = createClickUpServices({
-    apiKey: config.clickupApiKey,
-    teamId: config.clickupTeamId
-});
-// Extract the workspace service for use in this module
-const { workspace } = services;
+import { Logger } from "./logger.js";
+import { clickUpServices } from "./services/shared.js";
+// Create a logger instance for server
+const logger = new Logger('Server');
+// Use existing services from shared module instead of creating new ones
+const { workspace } = clickUpServices;
 /**
  * MCP Server for ClickUp integration
  */
@@ -29,7 +26,10 @@ export const server = new Server({
  * Configure the server routes and handlers
  */
 export function configureServer() {
+    logger.info("Registering server request handlers");
+    // Register ListTools handler
     server.setRequestHandler(ListToolsRequestSchema, async () => {
+        logger.debug("Received ListTools request");
         return {
             tools: [
                 workspaceHierarchyTool,
@@ -44,6 +44,7 @@ export function configureServer() {
                 updateBulkTasksTool,
                 moveBulkTasksTool,
                 deleteBulkTasksTool,
+                getTaskCommentsTool,
                 createListTool,
                 createListInFolderTool,
                 getListTool,
@@ -56,60 +57,80 @@ export function configureServer() {
             ]
         };
     });
+    // Register CallTool handler with proper logging
+    logger.info("Registering tool handlers", {
+        toolCount: 22,
+        categories: ["workspace", "task", "list", "folder"]
+    });
     server.setRequestHandler(CallToolRequestSchema, async (req) => {
         const { name, arguments: params } = req.params;
-        // Handle tool calls by routing to the appropriate handler
-        switch (name) {
-            case "get_workspace_hierarchy":
-                return handleGetWorkspaceHierarchy();
-            case "create_task":
-                return handleCreateTask(params);
-            case "update_task":
-                return handleUpdateTask(params);
-            case "move_task":
-                return handleMoveTask(params);
-            case "duplicate_task":
-                return handleDuplicateTask(params);
-            case "get_task":
-                return handleGetTask(params);
-            case "get_tasks":
-                return handleGetTasks(params);
-            case "delete_task":
-                return handleDeleteTask(params);
-            case "create_bulk_tasks":
-                return handleCreateBulkTasks(params);
-            case "update_bulk_tasks":
-                return handleUpdateBulkTasks(params);
-            case "move_bulk_tasks":
-                return handleMoveBulkTasks(params);
-            case "delete_bulk_tasks":
-                return handleDeleteBulkTasks(params);
-            case "create_list":
-                return handleCreateList(params);
-            case "create_list_in_folder":
-                return handleCreateListInFolder(params);
-            case "get_list":
-                return handleGetList(params);
-            case "update_list":
-                return handleUpdateList(params);
-            case "delete_list":
-                return handleDeleteList(params);
-            case "create_folder":
-                return handleCreateFolder(params);
-            case "get_folder":
-                return handleGetFolder(params);
-            case "update_folder":
-                return handleUpdateFolder(params);
-            case "delete_folder":
-                return handleDeleteFolder(params);
-            default:
-                throw new Error(`Unknown tool: ${name}`);
+        // Improved logging with more context
+        logger.info(`Received CallTool request for tool: ${name}`, {
+            params
+        });
+        try {
+            // Handle tool calls by routing to the appropriate handler
+            switch (name) {
+                case "get_workspace_hierarchy":
+                    return handleGetWorkspaceHierarchy();
+                case "create_task":
+                    return handleCreateTask(params);
+                case "update_task":
+                    return handleUpdateTask(params);
+                case "move_task":
+                    return handleMoveTask(params);
+                case "duplicate_task":
+                    return handleDuplicateTask(params);
+                case "get_task":
+                    return getTaskTool.handler(params);
+                case "get_tasks":
+                    return handleGetTasks(params);
+                case "delete_task":
+                    return handleDeleteTask(params);
+                case "create_bulk_tasks":
+                    return handleCreateBulkTasks(params);
+                case "update_bulk_tasks":
+                    return handleUpdateBulkTasks(params);
+                case "move_bulk_tasks":
+                    return handleMoveBulkTasks(params);
+                case "delete_bulk_tasks":
+                    return handleDeleteBulkTasks(params);
+                case "get_task_comments":
+                    return handleGetTaskComments(params);
+                case "create_list":
+                    return handleCreateList(params);
+                case "create_list_in_folder":
+                    return handleCreateListInFolder(params);
+                case "get_list":
+                    return handleGetList(params);
+                case "update_list":
+                    return handleUpdateList(params);
+                case "delete_list":
+                    return handleDeleteList(params);
+                case "create_folder":
+                    return handleCreateFolder(params);
+                case "get_folder":
+                    return handleGetFolder(params);
+                case "update_folder":
+                    return handleUpdateFolder(params);
+                case "delete_folder":
+                    return handleDeleteFolder(params);
+                default:
+                    logger.error(`Unknown tool requested: ${name}`);
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        }
+        catch (err) {
+            logger.error(`Error executing tool: ${name}`, err);
+            throw err;
         }
     });
     server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        logger.info("Received ListPrompts request");
         return { prompts: [] };
     });
     server.setRequestHandler(GetPromptRequestSchema, async () => {
+        logger.error("Received GetPrompt request, but prompts are not supported");
         throw new Error("Prompt not found");
     });
     return server;