ucm-mcp-server 6.6.0 → 6.7.0

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

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

package/dist/mcp-server/index.js

@@ -1,68 +0,0 @@
-#!/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

@@ -1,8 +0,0 @@
-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

@@ -1,4 +0,0 @@
-// 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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,16 +0,0 @@
-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

@@ -1,45 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,12 +0,0 @@
-// 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

@@ -1,26 +0,0 @@
-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

@@ -1,90 +0,0 @@
-// 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

@@ -1,12 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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