@taazkareem/clickup-mcp-server 0.6.1 → 0.6.2

package/build/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 /**
  * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
  * SPDX-License-Identifier: MIT

package/build/mcp-tools.js

@@ -0,0 +1,64 @@
+import { Logger } from "./logger.js";
+// Create a logger instance
+const logger = new Logger('MCPTools');
+/**
+ * Register a handler for a tool that may receive JSON string parameters
+ * This wrapper ensures that array and object parameters are properly parsed
+ *
+ * @param server MCP Server instance
+ * @param name Tool name
+ * @param handler Handler function
+ */
+export function registerToolHandler(server, name, handler) {
+    // Create a wrapper handler that pre-processes parameters
+    const wrappedHandler = async (params) => {
+        logger.debug(`Processing parameters for tool ${name}`, { params });
+        try {
+            // Process the parameters before passing them to the actual handler
+            const processedParams = {};
+            // Process each parameter - try to parse strings that might be JSON
+            for (const [key, value] of Object.entries(params)) {
+                if (typeof value === 'string') {
+                    try {
+                        // Check if this might be a JSON array or object
+                        if ((value.startsWith('[') && value.endsWith(']')) ||
+                            (value.startsWith('{') && value.endsWith('}'))) {
+                            try {
+                                processedParams[key] = JSON.parse(value);
+                                logger.debug(`Parsed JSON parameter: ${key}`, { original: value, parsed: processedParams[key] });
+                            }
+                            catch (parseError) {
+                                // If parsing fails, use the original string
+                                processedParams[key] = value;
+                                logger.debug(`Failed to parse JSON for parameter: ${key}, using original`, { error: parseError.message });
+                            }
+                        }
+                        else {
+                            processedParams[key] = value;
+                        }
+                    }
+                    catch (error) {
+                        // If there's any error, use the original value
+                        processedParams[key] = value;
+                        logger.debug(`Error processing parameter: ${key}`, { error: error.message });
+                    }
+                }
+                else {
+                    // Non-string values are used as-is
+                    processedParams[key] = value;
+                }
+            }
+            logger.debug(`Processed parameters for tool ${name}`, { processedParams });
+            // Call the original handler with processed parameters
+            return handler(processedParams);
+        }
+        catch (error) {
+            logger.error(`Error in wrapped handler for tool ${name}:`, { error: error.stack || error.message });
+            throw error;
+        }
+    };
+    // Use setRequestHandler to register the wrapped handler
+    logger.info(`Registering wrapped handler for tool: ${name}`);
+    // Override the tool's handler in the CallTool switch statement
+    // The server.ts file will use the switch case to call this handler
+}

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

@@ -19,7 +19,7 @@ const logger = new Logger('Server');
 const { workspace } = clickUpServices;
 export const server = new Server({
     name: "clickup-mcp-server",
-    version: "0.6.1",
+    version: "0.6.2",
 }, {
     capabilities: {
         tools: {},

package/build/tools/bulk-tasks.js

@@ -0,0 +1,36 @@
+/**
+ * Alternative implementation for bulk tasks creation
+ */
+import { handleCreateBulkTasks } from './task.js';
+/**
+ * Alternative tool definition for bulk task creation to work around MCP validation issues
+ */
+export const createTasksBulkTool = {
+    name: "create_tasks_bulk",
+    description: "Create multiple tasks in a list efficiently. You MUST provide:\n1. An array of tasks with required properties\n2. Either listId or listName to specify the target list",
+    inputSchema: {
+        type: "object",
+        properties: {
+            listId: {
+                type: "string",
+                description: "ID of list for new tasks (preferred). Use this instead of listName if you have it."
+            },
+            listName: {
+                type: "string",
+                description: "Name of list for new tasks. Only use if you don't have listId."
+            },
+            tasks: {
+                // Define minimally to avoid validation issues
+                description: "Array of tasks to create. Each task must have at least a name."
+            }
+        },
+        required: ["tasks"]
+    }
+};
+/**
+ * Handler for create_tasks_bulk tool
+ */
+export async function handleCreateTasksBulk(parameters) {
+    // Use the same implementation as handleCreateBulkTasks
+    return handleCreateBulkTasks(parameters);
+}

package/build/tools/debug.js

@@ -0,0 +1,76 @@
+/**
+ * Debug Tools
+ *
+ * This module provides tools for debugging and monitoring the ClickUp MCP server.
+ */
+// In-memory log storage
+const DEBUG_LOGS = [];
+/**
+ * Log a message to the in-memory debug logs
+ */
+export function logDebug(message, level = 'info') {
+    const timestamp = new Date().toISOString();
+    DEBUG_LOGS.push({ timestamp, message, level });
+    // Optional: Also print to console for development
+    if (level === 'error') {
+        console.error(`[${timestamp}] ERROR: ${message}`);
+    }
+    else if (level === 'warn') {
+        console.warn(`[${timestamp}] WARN: ${message}`);
+    }
+    else {
+        console.log(`[${timestamp}] INFO: ${message}`);
+    }
+}
+/**
+ * Tool definition for checking debug logs
+ */
+export const checkDebugLogsTool = {
+    name: 'check_debug_logs',
+    description: 'Check the server debug logs collected since the server started.',
+    inputSchema: {
+        type: 'object',
+        properties: {}
+    }
+};
+/**
+ * Tool definition for clearing debug logs
+ */
+export const clearDebugLogsTool = {
+    name: 'clear_debug_logs',
+    description: 'Clear all server debug logs.',
+    inputSchema: {
+        type: 'object',
+        properties: {}
+    }
+};
+/**
+ * Handler for the check_debug_logs tool
+ */
+export function handleCheckDebugLogs() {
+    return {
+        content: [
+            {
+                type: "text",
+                text: DEBUG_LOGS.length > 0
+                    ? DEBUG_LOGS.map(log => `[${log.timestamp}] [${log.level.toUpperCase()}] ${log.message}`).join('\n')
+                    : "No debug logs available."
+            }
+        ]
+    };
+}
+/**
+ * Handler for the clear_debug_logs tool
+ */
+export function handleClearDebugLogs() {
+    const count = DEBUG_LOGS.length;
+    DEBUG_LOGS.length = 0;
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Cleared ${count} debug log entries.`
+            }
+        ]
+    };
+}

package/build/tools/logs.js

@@ -0,0 +1,55 @@
+/**
+ * Simple Logs Tool
+ *
+ * Provides a basic tool for reading server logs.
+ */
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+// Define the log file path - using __dirname to get absolute path
+const LOG_FILE = join(dirname(__dirname), 'server.log');
+// Tool definition
+export const checkLogsTool = {
+    name: "check_logs",
+    description: "Check server logs with optional filtering by log level",
+    parameters: {
+        type: "object",
+        properties: {
+            level: {
+                type: "string",
+                enum: ["TRACE", "DEBUG", "INFO", "WARN", "ERROR"],
+                description: "Filter logs by level"
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of log entries to return (default: 50)"
+            }
+        }
+    }
+};
+// Simple handler implementation using async/await with promises
+export async function handleCheckLogs(params) {
+    try {
+        // Read log file using promises
+        const content = await fs.readFile(LOG_FILE, 'utf-8');
+        // Split into lines and filter out empty lines
+        let lines = content.split('\n').filter(Boolean);
+        // Apply level filtering if specified
+        if (params?.level) {
+            lines = lines.filter(line => line.includes(`${params.level}:`));
+        }
+        // Apply limit (default to 50)
+        const limit = params?.limit || 50;
+        const result = lines.slice(-limit);
+        // Return results
+        return {
+            logs: result.length > 0 ? result : ['No matching logs found.']
+        };
+    }
+    catch (error) {
+        // Simple error handling
+        if (error.code === 'ENOENT') {
+            return { logs: ['Log file not found.'] };
+        }
+        return { logs: [`Error reading logs: ${error.message}`] };
+    }
+}