@taazkareem/clickup-mcp-server 0.8.5 → 0.9.0

package/LICENSE

@@ -1,21 +1,13 @@
-MIT License
+Copyright (c) 2024-2025 Taaz Kareem
 
-Copyright (c) 2025 Talib Kareem
+All Rights Reserved
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+This software and associated documentation files (the "Software") are the proprietary 
+property of Talib Kareem. Unauthorized copying, modification, distribution, or use of 
+this Software, via any medium, is strictly prohibited without express written permission 
+from the copyright holder.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The Software is provided to authorized users only. Access is granted exclusively through 
+official channels and requires a valid license.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+For licensing inquiries, please visit: https://polar.sh/taazkareem

package/README.md

@@ -1,34 +1,21 @@
 <img src="assets/images/clickup_mcp_server_social_image.png" alt="ClickUp MCP Server" width="100%">
 
-![Total Supporters](https://img.shields.io/badge/🏆%20Total%20Supporters-4-gold)
-[![GitHub Stars](https://img.shields.io/github/stars/TaazKareem/clickup-mcp-server?style=flat&logo=github)](https://github.com/TaazKareem/clickup-mcp-server/stargazers)
-[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-brightgreen.svg)](https://github.com/TaazKareem/clickup-mcp-server/graphs/commit-activity)
+# ClickUp 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:** v0.8.5 is released with comprehensive natural language date parsing and critical bug fixes! Added 47+ natural language patterns (100% accuracy), extended time units (months/years), dynamic number support, fixed task assignment functionality, and resolved time tracking issues. See [Release Notes](release-notes.md) for full details.
-
-## Setup
+> **🔒 Premium Version** - Requires license key from [Polar.sh](https://polar.sh/taazkareem)
 
-1. Get your credentials:
-   - ClickUp API key from [ClickUp Settings](https://app.clickup.com/settings/apps)
-   - Team ID from your ClickUp workspace URL
-2. Choose either hosted installation (sends webhooks) or NPX installation (downloads to local path and installs dependencies)
-3. Use natural language to manage your workspace!
+[![License](https://img.shields.io/badge/License-Proprietary-red.svg)](LICENSE)
+[![Maintained](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/TaazKareem/clickup-mcp-server/graphs/commit-activity)
 
-## Smithery Installation (Quick Start)
-
-[![smithery badge](https://smithery.ai/badge/@taazkareem/clickup-mcp-server)](https://smithery.ai/server/@TaazKareem/clickup-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.
 
-The server is hosted on [Smithery](https://smithery.ai/server/@taazkareem/clickup-mcp-server). There, you can preview the available tools or copy the commands to run on your specific client app.
+## 🚀 Quick Start
 
-## NPX Installation
+### 1. Get Your License Key
 
-[![NPM Version](https://img.shields.io/npm/v/@taazkareem/clickup-mcp-server.svg?style=flat&logo=npm)](https://www.npmjs.com/package/@taazkareem/clickup-mcp-server)
-[![Dependency Status](https://img.shields.io/badge/dependencies-up%20to%20date-brightgreen)](https://github.com/TaazKareem/clickup-mcp-server/blob/main/package.json)
-[![NPM Downloads](https://img.shields.io/npm/dm/@taazkareem/clickup-mcp-server.svg?style=flat&logo=npm)](https://npmcharts.com/compare/@taazkareem/clickup-mcp-server?minimal=true)
+Purchase a license at **[polar.sh/taazkareem](https://polar.sh/taazkareem)**
 
-Add this entry to your client's MCP settings JSON file:
+### 2. Add to Your MCP Configuration
 
 ```json
 {
@@ -40,7 +27,8 @@ Add this entry to your client's MCP settings JSON file:
         "@taazkareem/clickup-mcp-server@latest"
       ],
       "env": {
-        "CLICKUP_API_KEY": "your-api-key",
+        "CLICKUP_MCP_LICENSE_KEY": "your-license-key-here",
+        "CLICKUP_API_KEY": "your-clickup-api-key",
         "CLICKUP_TEAM_ID": "your-team-id",
         "DOCUMENT_SUPPORT": "true"
       }
@@ -49,11 +37,18 @@ Add this entry to your client's MCP settings JSON file:
 }
 ```
 
-Or use this npx command:
+### 3. Restart Your MCP Client
 
-`npx -y @taazkareem/clickup-mcp-server@latest --env CLICKUP_API_KEY=your-api-key --env CLICKUP_TEAM_ID=your-team-id`
+That's it! The server will validate your license key and start automatically.
+
+**📖 [Full Installation Guide](INSTALLATION.md)** for detailed setup instructions.
+
+## Requirements
+
+- **Node.js v18.0.0 or higher** (required for MCP SDK compatibility)
+- Valid license key from [Polar.sh](https://polar.sh/taazkareem)
+- ClickUp API key and Team ID
 
-**Obs: if you don't pass "DOCUMENT_SUPPORT": "true", the default is false and document support will not be active.**
 
 ### Tool Filtering
 
@@ -307,30 +302,30 @@ The server provides clear error messages for:
 The `LOG_LEVEL` environment variable can be specified to control the verbosity of server logs. Valid values are `trace`, `debug`, `info`, `warn`, and `error` (default).
 This can be also be specified on the command line as, e.g. `--env LOG_LEVEL=info`.
 
-## Support the Developer
+## Premium Support
 
-When using this server, you may occasionally see a small sponsor message with a link to this repository included in tool responses. I hope you can support the project!
-If you find this project useful, please consider supporting:
+As a premium user, you have access to:
 
-[![Sponsor TaazKareem](https://img.shields.io/badge/Sponsor-TaazKareem-orange?logo=github)](https://github.com/sponsors/TaazKareem)
+- **Priority Support**: Open issues directly in this private repository
+- **Feature Requests**: Request new features and capabilities
+- **Automatic Updates**: Pull the latest features and bug fixes
+- **Direct Communication**: Get help from the maintainer
 
-<a href="https://buymeacoffee.com/taazkareem">
-  <img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" width="200" alt="Buy Me A Coffee">
-</a>
+To get support, [open an issue](https://github.com/TaazKareem/clickup-mcp-server/issues) in this repository.
 
 ## Acknowledgements
 
 Special thanks to [ClickUp](https://clickup.com) for their excellent API and services that make this integration possible.
 
-## Contributing
-
-Contributions are welcome! Please read our [Contributing Guide](CONTRIBUTING.md) for details.
+Thank you to all supporters who make continued development possible! 🙏
 
 ## License
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![License](https://img.shields.io/badge/License-Proprietary-red.svg)](LICENSE)
+
+This project is licensed under a proprietary license - see the [LICENSE](LICENSE) file for details.
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+**All Rights Reserved** - Unauthorized copying, modification, distribution, or use is strictly prohibited.
 
 ## Disclaimer
 

package/build/enhanced_server.js

@@ -0,0 +1,262 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * Enhanced ClickUp MCP Server with Simplified OAuth2 Support
+ *
+ * This module extends the existing SSE/HTTP server with simplified OAuth2 authentication
+ * capabilities while maintaining backward compatibility with API key authentication.
+ * Uses in-memory session management instead of database persistence.
+ */
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import express from 'express';
+import cookieParser from 'cookie-parser';
+import { server, configureServer } from './server.js';
+import configuration from './config.js';
+import { SessionService } from './services/auth/session.js';
+import { AuthRoutes } from './routes/auth.js';
+import { AuthMiddleware } from './middleware/auth.js';
+import { Logger } from './logger.js';
+/**
+ * Enhanced server class with simplified OAuth2 support
+ */
+export class EnhancedServer {
+    constructor() {
+        this.sessionService = null;
+        this.authRoutes = null;
+        this.authMiddleware = null;
+        this.transports = {
+            streamable: {},
+            sse: {},
+        };
+        this.app = express();
+        this.logger = new Logger('EnhancedServer');
+        this.setupMiddleware();
+    }
+    /**
+     * Setup Express middleware (simplified)
+     * @private
+     */
+    setupMiddleware() {
+        // Basic middleware
+        this.app.use(express.json());
+        this.app.use(cookieParser());
+        // CORS middleware for OAuth2 endpoints
+        this.app.use((req, res, next) => {
+            res.header('Access-Control-Allow-Origin', '*');
+            res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization, mcp-session-id');
+            if (req.method === 'OPTIONS') {
+                res.sendStatus(200);
+            }
+            else {
+                next();
+            }
+        });
+    }
+    /**
+     * Initialize simplified OAuth2 services if enabled
+     * @private
+     */
+    async initializeOAuth2() {
+        if (!configuration.enableOAuth2) {
+            this.logger.info('OAuth2 disabled, skipping initialization');
+            return;
+        }
+        this.logger.info('Initializing simplified OAuth2 services');
+        try {
+            // Initialize simple session service (in-memory)
+            this.sessionService = new SessionService();
+            // Initialize authentication middleware
+            this.authMiddleware = new AuthMiddleware(this.sessionService);
+            // Initialize OAuth2 routes
+            this.authRoutes = new AuthRoutes({
+                clientId: configuration.oauth2ClientId,
+                clientSecret: configuration.oauth2ClientSecret,
+                redirectUri: configuration.oauth2RedirectUri
+            }, this.sessionService);
+            // Mount OAuth2 routes
+            this.app.use('/auth', this.authRoutes.getRouter());
+            this.logger.info('Simplified OAuth2 services initialized successfully');
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize OAuth2 services', { error: error.message });
+            throw error;
+        }
+    }
+    /**
+     * Setup MCP endpoints (existing functionality)
+     * @private
+     */
+    setupMCPEndpoints() {
+        // Configure the unified server first
+        configureServer();
+        // Streamable HTTP endpoint - handles POST requests for client-to-server communication
+        this.app.post('/mcp', async (req, res) => {
+            try {
+                const sessionId = req.headers['mcp-session-id'];
+                let transport;
+                if (sessionId && this.transports.streamable[sessionId]) {
+                    transport = this.transports.streamable[sessionId];
+                }
+                else if (!sessionId && isInitializeRequest(req.body)) {
+                    transport = new StreamableHTTPServerTransport({
+                        sessionIdGenerator: () => `session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`,
+                        onsessioninitialized: (sessionId) => {
+                            this.transports.streamable[sessionId] = transport;
+                        }
+                    });
+                    transport.onclose = () => {
+                        if (transport.sessionId) {
+                            delete this.transports.streamable[transport.sessionId];
+                        }
+                    };
+                    await server.connect(transport);
+                }
+                else {
+                    res.status(400).json({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32000,
+                            message: 'Bad Request: No valid session ID provided',
+                        },
+                        id: null,
+                    });
+                    return;
+                }
+                await transport.handleRequest(req, res, req.body);
+            }
+            catch (error) {
+                this.logger.error('Error handling MCP request', { error });
+                if (!res.headersSent) {
+                    res.status(500).json({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32603,
+                            message: 'Internal server error',
+                        },
+                        id: null,
+                    });
+                }
+            }
+        });
+        const handleSessionRequest = async (req, res) => {
+            const sessionId = req.headers['mcp-session-id'];
+            if (!sessionId || !this.transports.streamable[sessionId]) {
+                res.status(400).send('Invalid or missing session ID');
+                return;
+            }
+            const transport = this.transports.streamable[sessionId];
+            await transport.handleRequest(req, res);
+        };
+        this.app.get('/mcp', handleSessionRequest);
+        this.app.delete('/mcp', handleSessionRequest);
+        // Legacy SSE endpoints (for backwards compatibility)
+        this.app.get('/sse', async (req, res) => {
+            const transport = new SSEServerTransport('/messages', res);
+            this.transports.sse[transport.sessionId] = transport;
+            this.logger.info('New SSE connection established', { sessionId: transport.sessionId });
+            res.on('close', () => {
+                delete this.transports.sse[transport.sessionId];
+            });
+            await server.connect(transport);
+        });
+        this.app.post('/messages', async (req, res) => {
+            const sessionId = req.query.sessionId;
+            const transport = this.transports.sse[sessionId];
+            if (transport) {
+                await transport.handlePostMessage(req, res, req.body);
+            }
+            else {
+                res.status(400).send('No transport found for sessionId');
+            }
+        });
+    }
+    /**
+     * Setup health check and info endpoints (simplified)
+     * @private
+     */
+    setupUtilityEndpoints() {
+        // Health check endpoint
+        this.app.get('/health', async (req, res) => {
+            const health = {
+                status: 'healthy',
+                timestamp: new Date().toISOString(),
+                version: process.env.npm_package_version || 'unknown',
+                oauth2Enabled: configuration.enableOAuth2
+            };
+            if (this.sessionService) {
+                health.sessions = {
+                    active: this.sessionService.getSessionCount(),
+                    type: 'in-memory'
+                };
+            }
+            res.json(health);
+        });
+        // Server info endpoint
+        this.app.get('/info', (req, res) => {
+            res.json({
+                name: 'ClickUp MCP Server',
+                version: process.env.npm_package_version || 'unknown',
+                oauth2Enabled: configuration.enableOAuth2,
+                sessionType: configuration.enableOAuth2 ? 'in-memory' : null,
+                endpoints: {
+                    mcp: '/mcp',
+                    sse: '/sse',
+                    auth: configuration.enableOAuth2 ? '/auth' : null,
+                    health: '/health'
+                }
+            });
+        });
+    }
+    /**
+     * Start the enhanced server
+     */
+    async start() {
+        try {
+            this.logger.info('Starting enhanced ClickUp MCP server');
+            // Initialize OAuth2 if enabled
+            await this.initializeOAuth2();
+            // Setup all endpoints
+            this.setupMCPEndpoints();
+            this.setupUtilityEndpoints();
+            const PORT = Number(configuration.port ?? '3231');
+            // Start the server
+            this.app.listen(PORT, () => {
+                this.logger.info('Enhanced server started', { port: PORT });
+                console.log(`Enhanced ClickUp MCP Server started on http://127.0.0.1:${PORT}`);
+                console.log(`Streamable HTTP endpoint: http://127.0.0.1:${PORT}/mcp`);
+                console.log(`Legacy SSE endpoint: http://127.0.0.1:${PORT}/sse`);
+                if (configuration.enableOAuth2) {
+                    console.log(`OAuth2 login: http://127.0.0.1:${PORT}/auth/login`);
+                    console.log(`OAuth2 callback: http://127.0.0.1:${PORT}/auth/callback`);
+                }
+                console.log(`Health check: http://127.0.0.1:${PORT}/health`);
+                console.log(`Server info: http://127.0.0.1:${PORT}/info`);
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to start enhanced server', { error: error.message });
+            throw error;
+        }
+    }
+    /**
+     * Shutdown the server gracefully (simplified)
+     */
+    async shutdown() {
+        this.logger.info('Shutting down enhanced server');
+        if (this.sessionService) {
+            this.sessionService.destroy();
+        }
+        this.logger.info('Enhanced server shutdown complete');
+    }
+}
+/**
+ * Start the enhanced server
+ */
+export async function startEnhancedServer() {
+    const enhancedServer = new EnhancedServer();
+    await enhancedServer.start();
+}

package/build/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 /**
  * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
- * SPDX-License-Identifier: MIT
+ * SPDX-License-Identifier: Proprietary
  *
- * ClickUp MCP Server
+ * ClickUp MCP Server Premium
  *
  * This custom server implements the Model Context Protocol (MCP) specification to enable
  * AI applications to interact with ClickUp workspaces. It provides a standardized
@@ -20,6 +20,8 @@
  * - Built-in rate limiting
  * - Multiple transport options (STDIO, SSE, HTTP Streamable)
  *
+ * PREMIUM VERSION - Requires valid license key from https://polar.sh/taazkareem
+ *
  * For full documentation and usage examples, please refer to the README.md file.
  */
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -29,6 +31,7 @@ import config from './config.js';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { startSSEServer } from './sse_server.js';
+import { initializeLicense } from './license.js';
 // Get directory name for module paths
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Handle uncaught exceptions
@@ -42,7 +45,7 @@ process.on('unhandledRejection', (reason, promise) => {
     process.exit(1);
 });
 async function startStdioServer() {
-    info('Starting ClickUp MCP Server...');
+    info('Starting ClickUp MCP Server Premium...');
     // Log essential information about the environment
     info('Server environment', {
         pid: process.pid,
@@ -61,9 +64,12 @@ async function startStdioServer() {
 }
 /**
  * Application entry point that configures and starts the MCP server.
+ * Validates license key at startup (server starts regardless, but tools will fail if invalid).
  */
 async function main() {
     try {
+        // Validate license key (doesn't exit - just sets status for tool calls)
+        await initializeLicense();
         if (config.enableSSE) {
             // Start the new SSE server with HTTP Streamable support
             startSSEServer();

package/build/license.js

@@ -0,0 +1,172 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: Proprietary
+ *
+ * License validation for ClickUp MCP Server Premium
+ *
+ * Uses Polar.sh Customer Portal API for license key validation.
+ * This endpoint is public and doesn't require authentication.
+ */
+import axios from 'axios';
+// Your Polar.sh organization ID
+const POLAR_ORGANIZATION_ID = 'cd9f6f7c-5b51-4e5e-872b-c92dd9377bcd';
+// Polar.sh API endpoint for license validation (public, no auth required)
+const POLAR_VALIDATE_URL = 'https://api.polar.sh/v1/customer-portal/license-keys/validate';
+// Purchase link for error messages
+const PURCHASE_URL = 'https://buy.polar.sh/polar_cl_3xQojQLgzQXKCLzsxc49YfL6z8hzSBBqh9ivy1qZdwW';
+// Global license status - validated once at startup
+let licenseStatus = {
+    isValid: false,
+    status: 'missing',
+    errorMessage: 'License not yet validated'
+};
+/**
+ * Get the current license status
+ */
+export function getLicenseStatus() {
+    return licenseStatus;
+}
+/**
+ * Check if the license is valid
+ */
+export function isLicenseValid() {
+    return licenseStatus.isValid;
+}
+/**
+ * Get the license error message for tool calls
+ */
+export function getLicenseErrorMessage() {
+    const baseMessage = `
+❌ LICENSE KEY REQUIRED
+
+This is a premium version of ClickUp MCP Server.
+A valid license key is required to use these tools.
+
+👉 Get your license key at:
+   ${PURCHASE_URL}
+
+After purchase, add the license key to your MCP configuration:
+
+{
+  "env": {
+    "CLICKUP_MCP_LICENSE_KEY": "your-license-key-here",
+    "CLICKUP_API_KEY": "...",
+    "CLICKUP_TEAM_ID": "..."
+  }
+}
+
+Then restart your MCP client.
+`;
+    if (licenseStatus.errorMessage) {
+        return `${baseMessage}\nError Details: ${licenseStatus.errorMessage}`;
+    }
+    return baseMessage;
+}
+/**
+ * Validates a license key with Polar.sh
+ */
+async function validateLicenseKey(licenseKey) {
+    if (!licenseKey || licenseKey.trim() === '') {
+        return {
+            isValid: false,
+            status: 'missing',
+            errorMessage: 'No license key provided'
+        };
+    }
+    try {
+        const response = await axios.post(POLAR_VALIDATE_URL, {
+            key: licenseKey.trim(),
+            organization_id: POLAR_ORGANIZATION_ID
+        }, {
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            timeout: 10000 // 10 second timeout
+        });
+        const data = response.data;
+        // Check license status
+        if (data.status === 'granted') {
+            // Check expiration
+            if (data.expires_at) {
+                const expiresAt = new Date(data.expires_at);
+                if (expiresAt < new Date()) {
+                    return {
+                        isValid: false,
+                        status: 'expired',
+                        expiresAt: data.expires_at,
+                        errorMessage: 'License key has expired'
+                    };
+                }
+            }
+            return {
+                isValid: true,
+                status: 'granted',
+                customerEmail: data.customer?.email,
+                expiresAt: data.expires_at
+            };
+        }
+        return {
+            isValid: false,
+            status: data.status,
+            errorMessage: `License key status: ${data.status}`
+        };
+    }
+    catch (error) {
+        // Handle specific error cases
+        if (error.response) {
+            const status = error.response.status;
+            if (status === 404) {
+                return {
+                    isValid: false,
+                    status: 'error',
+                    errorMessage: 'Invalid license key'
+                };
+            }
+            if (status === 422) {
+                return {
+                    isValid: false,
+                    status: 'error',
+                    errorMessage: 'Invalid license key format'
+                };
+            }
+        }
+        // Network or other errors - fail open with warning to avoid blocking due to temporary issues
+        console.error('Warning: Could not validate license key due to network error. Allowing access.');
+        return {
+            isValid: true,
+            status: 'granted',
+            errorMessage: 'License validation skipped due to network error (allowing access)'
+        };
+    }
+}
+/**
+ * Initialize license validation at startup
+ * Call this once when the server starts - it doesn't exit, just sets the status
+ */
+export async function initializeLicense() {
+    const licenseKey = process.env.CLICKUP_MCP_LICENSE_KEY;
+    if (!licenseKey) {
+        licenseStatus = {
+            isValid: false,
+            status: 'missing',
+            errorMessage: 'CLICKUP_MCP_LICENSE_KEY environment variable not set'
+        };
+        console.error('⚠️  License key not provided. Tools will return license error.');
+    }
+    else {
+        licenseStatus = await validateLicenseKey(licenseKey);
+        if (licenseStatus.isValid) {
+            if (licenseStatus.customerEmail) {
+                console.error(`✅ License validated for: ${licenseStatus.customerEmail}`);
+            }
+            else {
+                console.error('✅ License validated successfully');
+            }
+        }
+        else {
+            console.error(`⚠️  License validation failed: ${licenseStatus.errorMessage}`);
+            console.error('   Tools will return license error until a valid key is provided.');
+        }
+    }
+    return licenseStatus;
+}