@utaba/ucm-mcp-server 6.5.0 → 6.6.0

package/dist/mcp-server/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp-server/index.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { EventEmitter } from 'events';
+import { Command } from 'commander';
+import { McpServer } from './server/McpServer.js';
+import { McpConfig } from './server/McpConfig.js';
+import { LoggerFactory } from './logging/LoggerFactory.js';
+// Increase max listeners to prevent AbortSignal memory leak warnings
+// This is a safety net while we also implement proper cleanup
+EventEmitter.defaultMaxListeners = 40;
+async function main() {
+    const program = new Command();
+    program
+        .name('ucm-mcp-server')
+        .description('Universal Context Manager - Read the ucm_connect tool first to avoid mistakes')
+        .version('6.6.0')
+        .option('-u, --ucm-url <url>', 'UCM API base URL (defaults to https://ucm.utaba.ai)')
+        .option('-p, --port <port>', 'Server port', '3001')
+        .option('--log-level <level>', 'Log level', 'ERROR')
+        .option('--auth-token <token>', 'Authentication token for UCM API format is {auhtorid}:{apikey}. Get one from https://ucm.utaba.ai')
+        .option('--trusted-authors <authors>', 'Comma-separated list of trusted authors (e.g., "utaba,{anotherauthor}")', "utaba")
+        .parse();
+    const options = program.opts();
+    const config = new McpConfig({
+        ucmApiUrl: options.ucmUrl,
+        port: parseInt(options.port),
+        logLevel: options.logLevel,
+        authToken: options.authToken,
+        trustedAuthors: options.trustedAuthors ? options.trustedAuthors.split(',').map((a) => a.trim()) : ["utaba"]
+    });
+    // Set the log level in the factory before creating any loggers
+    LoggerFactory.setLogLevel(config.logLevel);
+    const logger = LoggerFactory.createLogger('MCP-Server');
+    const server = new McpServer(config, logger);
+    try {
+        await server.start();
+        logger.info('MCP-Server', 'UCM MCP Server started successfully');
+    }
+    catch (error) {
+        logger.error('MCP-Server', 'Failed to start UCM MCP Server', '', error);
+        process.exit(1);
+    }
+    // Graceful shutdown handlers
+    const gracefulShutdown = async (signal) => {
+        logger.info('MCP-Server', `Received ${signal}, shutting down UCM MCP Server...`);
+        try {
+            await server.stop();
+            logger.info('MCP-Server', 'UCM MCP Server shutdown complete');
+            process.exit(0);
+        }
+        catch (error) {
+            logger.error('MCP-Server', 'Error during shutdown', '', error);
+            process.exit(1);
+        }
+    };
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    // Handle uncaught exceptions and unhandled rejections
+    process.on('uncaughtException', (error) => {
+        logger.error('MCP-Server', 'Uncaught exception', '', error);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+        logger.error('MCP-Server', 'Unhandled rejection', '', { reason, promise });
+        process.exit(1);
+    });
+}
+main().catch(console.error);
+//# sourceMappingURL=index.js.map

package/dist/mcp-server/interfaces/ILogger.d.ts

@@ -0,0 +1,8 @@
+export interface ILogger {
+    debug(component: string, message: string, context?: string, metadata?: any): void;
+    info(component: string, message: string, context?: string, metadata?: any): void;
+    warn(component: string, message: string, context?: string, metadata?: any): void;
+    error(component: string, message: string, context?: string, metadata?: any): void;
+    logPerformance(component: string, operation: string, fileSize?: number, duration?: number, quota?: number): void;
+}
+//# sourceMappingURL=ILogger.d.ts.map

package/dist/mcp-server/interfaces/ILogger.js

@@ -0,0 +1,4 @@
+// Source: Duplicated from ../core/logging/ILogger.ts for MCP Server independence
+// Sync with Next.js app logging interface when updates are made
+export {};
+//# sourceMappingURL=ILogger.js.map

package/dist/mcp-server/interfaces/IMcpTool.d.ts

@@ -0,0 +1,7 @@
+export interface IMcpTool {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Record<string, unknown>;
+    execute(params: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=IMcpTool.d.ts.map

package/dist/mcp-server/interfaces/IMcpTool.js

@@ -0,0 +1,3 @@
+// MCP Tool interface for all UCM MCP tools
+export {};
+//# sourceMappingURL=IMcpTool.js.map

package/dist/mcp-server/logging/ConsoleLogger.d.ts

@@ -0,0 +1,16 @@
+import { ILogger } from '../interfaces/ILogger.js';
+type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+export declare class ConsoleLogger implements ILogger {
+    private defaultComponent;
+    private logLevel;
+    private logLevelPriority;
+    constructor(defaultComponent: string, logLevel?: LogLevel);
+    private shouldLog;
+    debug(component: string, message: string, context?: string, metadata?: any): void;
+    info(component: string, message: string, context?: string, metadata?: any): void;
+    warn(component: string, message: string, context?: string, metadata?: any): void;
+    error(component: string, message: string, context?: string, metadata?: any): void;
+    logPerformance(component: string, operation: string, fileSize?: number, duration?: number, quota?: number): void;
+}
+export {};
+//# sourceMappingURL=ConsoleLogger.d.ts.map

package/dist/mcp-server/logging/ConsoleLogger.js

@@ -0,0 +1,45 @@
+// Source: Duplicated from ../core/logging/ConsoleLogger.ts for MCP Server independence
+// Sync with Next.js app logger when updates are made
+export class ConsoleLogger {
+    defaultComponent;
+    logLevel;
+    logLevelPriority = {
+        'DEBUG': 0,
+        'INFO': 1,
+        'WARN': 2,
+        'ERROR': 3
+    };
+    constructor(defaultComponent, logLevel = 'INFO') {
+        this.defaultComponent = defaultComponent;
+        this.logLevel = logLevel;
+    }
+    shouldLog(level) {
+        return this.logLevelPriority[level] >= this.logLevelPriority[this.logLevel];
+    }
+    debug(component, message, context, metadata) {
+        if (this.shouldLog('DEBUG')) {
+            console.debug(`[DEBUG] ${component}: ${message}`, metadata || '');
+        }
+    }
+    info(component, message, context, metadata) {
+        if (this.shouldLog('INFO')) {
+            console.info(`[INFO] ${component}: ${message}`, metadata || '');
+        }
+    }
+    warn(component, message, context, metadata) {
+        if (this.shouldLog('WARN')) {
+            console.warn(`[WARN] ${component}: ${message}`, metadata || '');
+        }
+    }
+    error(component, message, context, metadata) {
+        if (this.shouldLog('ERROR')) {
+            console.error(`[ERROR] ${component}: ${message}`, metadata || '');
+        }
+    }
+    logPerformance(component, operation, fileSize, duration, quota) {
+        if (this.shouldLog('INFO')) {
+            console.info(`[PERF] ${component}: ${operation} - Duration: ${duration}ms`);
+        }
+    }
+}
+//# sourceMappingURL=ConsoleLogger.js.map

package/dist/mcp-server/logging/LoggerFactory.d.ts

@@ -0,0 +1,9 @@
+import { ILogger } from '../interfaces/ILogger.js';
+type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+export declare class LoggerFactory {
+    private static logLevel;
+    static setLogLevel(level: LogLevel): void;
+    static createLogger(component: string): ILogger;
+}
+export {};
+//# sourceMappingURL=LoggerFactory.d.ts.map

package/dist/mcp-server/logging/LoggerFactory.js

@@ -0,0 +1,12 @@
+// MCP Server-specific logger factory
+import { ConsoleLogger } from './ConsoleLogger.js';
+export class LoggerFactory {
+    static logLevel = 'INFO';
+    static setLogLevel(level) {
+        this.logLevel = level;
+    }
+    static createLogger(component) {
+        return new ConsoleLogger(component, this.logLevel);
+    }
+}
+//# sourceMappingURL=LoggerFactory.js.map

package/dist/mcp-server/server/McpConfig.d.ts

@@ -0,0 +1,26 @@
+export interface McpServerConfig {
+    ucmApiUrl: string;
+    port: number;
+    authToken?: string;
+    authorId?: string;
+    logLevel: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+    requestTimeout: number;
+    trustedAuthors: string[];
+}
+export declare class McpConfig {
+    private config;
+    constructor(options?: Partial<McpServerConfig>);
+    private extractAuthorIdFromToken;
+    private getEnvVar;
+    private parseTrustedAuthors;
+    private validateConfig;
+    get ucmApiUrl(): string;
+    get port(): number;
+    get authToken(): string | undefined;
+    get logLevel(): 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+    get requestTimeout(): number;
+    get trustedAuthors(): string[];
+    get authorId(): string | undefined;
+    getFullConfig(): McpServerConfig;
+}
+//# sourceMappingURL=McpConfig.d.ts.map

package/dist/mcp-server/server/McpConfig.js

@@ -0,0 +1,90 @@
+// Source: Independent MCP Server configuration management
+// This class centralizes ALL MCP Server configuration and environment variables
+export class McpConfig {
+    config;
+    constructor(options = {}) {
+        const authToken = options.authToken || this.getEnvVar('UCM_AUTH_TOKEN', '');
+        const authorId = this.extractAuthorIdFromToken(authToken);
+        this.config = {
+            ucmApiUrl: options.ucmApiUrl || this.getEnvVar('UCM_API_URL', 'https://ucm.utaba.ai'),
+            port: options.port || parseInt(this.getEnvVar('MCP_PORT', '3001')),
+            authToken: authToken,
+            authorId: options.authorId || authorId,
+            logLevel: options.logLevel || this.getEnvVar('MCP_LOG_LEVEL', 'ERROR'),
+            requestTimeout: options.requestTimeout || parseInt(this.getEnvVar('MCP_REQUEST_TIMEOUT', '300000')),
+            trustedAuthors: options.trustedAuthors || this.parseTrustedAuthors(this.getEnvVar('MCP_TRUSTED_AUTHORS', ''))
+        };
+        this.validateConfig();
+    }
+    extractAuthorIdFromToken(authToken) {
+        if (!authToken || authToken.trim() === '') {
+            return undefined;
+        }
+        const parts = authToken.split(':');
+        if (parts.length >= 2 && parts[0].trim() !== '') {
+            return parts[0].trim();
+        }
+        return undefined;
+    }
+    getEnvVar(name, defaultValue) {
+        const value = process.env[name];
+        if (value !== undefined) {
+            return value;
+        }
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        throw new Error(`Required environment variable ${name} is not set`);
+    }
+    parseTrustedAuthors(authorsString) {
+        if (!authorsString || authorsString.trim() === '') {
+            return [];
+        }
+        const authors = authorsString.split(',').map(author => author.trim()).filter(Boolean);
+        const validAuthorPattern = /^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$/;
+        for (const author of authors) {
+            if (!validAuthorPattern.test(author)) {
+                throw new Error(`Invalid trusted author format: "${author}". Authors must be alphanumeric with optional hyphens (no consecutive hyphens).`);
+            }
+        }
+        return authors;
+    }
+    validateConfig() {
+        if (!this.config.ucmApiUrl.startsWith('http')) {
+            throw new Error('UCM API URL must be a valid HTTP/HTTPS URL');
+        }
+        if (this.config.port < 1 || this.config.port > 65535) {
+            throw new Error('Port must be between 1 and 65535');
+        }
+        if (!['DEBUG', 'INFO', 'WARN', 'ERROR'].includes(this.config.logLevel)) {
+            throw new Error('Log level must be one of: DEBUG, INFO, WARN, ERROR');
+        }
+    }
+    // Getters for configuration values
+    get ucmApiUrl() {
+        return this.config.ucmApiUrl;
+    }
+    get port() {
+        return this.config.port;
+    }
+    get authToken() {
+        return this.config.authToken;
+    }
+    get logLevel() {
+        return this.config.logLevel;
+    }
+    get requestTimeout() {
+        return this.config.requestTimeout;
+    }
+    get trustedAuthors() {
+        return this.config.trustedAuthors;
+    }
+    get authorId() {
+        return this.config.authorId;
+    }
+    // Get full configuration object (for testing and debugging)
+    getFullConfig() {
+        return { ...this.config };
+    }
+}
+//# sourceMappingURL=McpConfig.js.map

package/dist/mcp-server/server/McpHandler.d.ts

@@ -0,0 +1,12 @@
+import { ILogger } from '../interfaces/ILogger.js';
+import { ToolRegistry } from './ToolRegistry.js';
+export declare class McpHandler {
+    private toolRegistry;
+    private logger;
+    private authorId?;
+    constructor(toolRegistry: ToolRegistry, logger: ILogger, authorId?: string | undefined);
+    handlePing(): Promise<any>;
+    handleToolsList(): Promise<any>;
+    handleToolCall(request: any): Promise<any>;
+}
+//# sourceMappingURL=McpHandler.d.ts.map

package/dist/mcp-server/server/McpHandler.js

@@ -0,0 +1,84 @@
+import { McpError, McpErrorCode, McpErrorHandler } from '../utils/McpErrorHandler.js';
+export class McpHandler {
+    toolRegistry;
+    logger;
+    authorId;
+    constructor(toolRegistry, logger, authorId) {
+        this.toolRegistry = toolRegistry;
+        this.logger = logger;
+        this.authorId = authorId;
+    }
+    async handlePing() {
+        this.logger.debug('MCP-Handler', 'Received ping request');
+        return {};
+    }
+    async handleToolsList() {
+        this.logger.debug('MCP-Handler', 'Received tools/list request');
+        try {
+            const tools = await this.toolRegistry.listTools();
+            this.logger.info('MCP-Handler', `Returning ${tools.length} available tools`);
+            return {
+                tools: tools.map(tool => ({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema
+                }))
+            };
+        }
+        catch (error) {
+            this.logger.error('MCP-Handler', 'Failed to list tools', '', error);
+            throw new McpError(McpErrorCode.InternalError, 'Failed to retrieve tool list');
+        }
+    }
+    async handleToolCall(request) {
+        const { name, arguments: args } = request.params;
+        this.logger.debug('MCP-Handler', `Received tool call for: ${name}`);
+        try {
+            if (!name) {
+                throw new McpError(McpErrorCode.InvalidParams, 'Tool name is required');
+            }
+            const result = await this.toolRegistry.executeTool(name, args || {});
+            this.logger.info('MCP-Handler', `Tool ${name} executed successfully`);
+            // If the tool returned a pre-formatted MCP response (with content array), pass through
+            if (result && typeof result === 'object' && Array.isArray(result.content)) {
+                return result;
+            }
+            // Handle string results directly (e.g., markdown content)
+            if (typeof result === 'string') {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: result
+                        }
+                    ]
+                };
+            }
+            // For objects/arrays, use JSON.stringify
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            this.logger.error('MCP-Handler', `Tool execution failed for ${name}`, '', error);
+            // Format the error message for Claude Desktop to display properly
+            const formattedError = McpErrorHandler.formatError(error);
+            // Instead of throwing, return the error as content so Claude Desktop displays it
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${formattedError.message}`
+                    }
+                ],
+                isError: true
+            };
+        }
+    }
+}
+//# sourceMappingURL=McpHandler.js.map

package/dist/mcp-server/server/McpServer.d.ts

@@ -0,0 +1,15 @@
+import { McpConfig } from './McpConfig.js';
+import { ILogger } from '../interfaces/ILogger.js';
+export declare class McpServer {
+    private config;
+    private logger;
+    private server;
+    private handler;
+    private ucmClient;
+    private toolRegistry;
+    constructor(config: McpConfig, logger: ILogger);
+    private setupHandlers;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=McpServer.d.ts.map

package/dist/mcp-server/server/McpServer.js

@@ -0,0 +1,49 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { McpHandler } from './McpHandler.js';
+import { UcmLocalApiClient } from '../clients/UcmLocalApiClient.js';
+import { ToolRegistry } from './ToolRegistry.js';
+export class McpServer {
+    config;
+    logger;
+    server;
+    handler;
+    ucmClient;
+    toolRegistry;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        this.ucmClient = new UcmLocalApiClient(config.ucmApiUrl, config.authToken, config.requestTimeout, config.authorId);
+        this.toolRegistry = new ToolRegistry(this.ucmClient, this.logger, config.trustedAuthors, config.authorId, config.ucmApiUrl);
+        this.handler = new McpHandler(this.toolRegistry, this.logger, config.authorId);
+        this.server = new Server({
+            name: 'ucm-mcp-server',
+            version: '1.0.0',
+            description: 'UCM Model Context Protocol Server - https://ucm.utaba.ai'
+        }, {
+            capabilities: {
+                tools: {},
+                logging: {}
+            }
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, this.handler.handleToolsList.bind(this.handler));
+        this.server.setRequestHandler(CallToolRequestSchema, this.handler.handleToolCall.bind(this.handler));
+    }
+    async start() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        this.logger.info('MCP-Server', 'MCP Server connected via stdio transport');
+    }
+    async stop() {
+        // Cleanup HTTP client to prevent memory leaks from AbortSignal listeners
+        this.ucmClient.cleanup();
+        this.logger.info('MCP-Server', 'UCM API client cleaned up');
+        await this.server.close();
+        this.logger.info('MCP-Server', 'MCP Server stopped');
+    }
+}
+//# sourceMappingURL=McpServer.js.map

package/dist/mcp-server/server/ToolRegistry.d.ts

@@ -0,0 +1,23 @@
+import { UcmLocalApiClient } from '../clients/UcmLocalApiClient.js';
+import { ILogger } from '../interfaces/ILogger.js';
+export interface ToolInfo {
+    name: string;
+    description: string;
+    inputSchema: any;
+}
+export declare class ToolRegistry {
+    private ucmClient;
+    private logger;
+    private trustedAuthors;
+    private authorId?;
+    private baseUrl?;
+    private tools;
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, trustedAuthors?: string[], authorId?: string | undefined, baseUrl?: string | undefined);
+    private registerTools;
+    private registerTool;
+    listTools(): Promise<ToolInfo[]>;
+    executeTool(name: string, params: any): Promise<any>;
+    getToolCount(): number;
+    hasToolnamed(name: string): boolean;
+}
+//# sourceMappingURL=ToolRegistry.d.ts.map