@utaba/ucm-mcp-server 1.0.0

package/dist/server/McpConfig.js

@@ -0,0 +1,93 @@
+// 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', '30000')),
+            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) {
+            throw new Error('UCM API URL is required');
+        }
+        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/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/server/McpHandler.js

@@ -0,0 +1,69 @@
+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`);
+            // 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);
+            throw McpErrorHandler.formatError(error);
+        }
+    }
+}
+//# sourceMappingURL=McpHandler.js.map

package/dist/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/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 { UcmApiClient } from '../clients/UcmApiClient.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 UcmApiClient(config.ucmApiUrl, config.authToken, config.requestTimeout, config.authorId);
+        this.toolRegistry = new ToolRegistry(this.ucmClient, this.logger, config.trustedAuthors, config.authorId);
+        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/server/ToolRegistry.d.ts

@@ -0,0 +1,22 @@
+import { UcmApiClient } from '../clients/UcmApiClient.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 tools;
+    constructor(ucmClient: UcmApiClient, logger: ILogger, trustedAuthors?: string[], authorId?: 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

package/dist/server/ToolRegistry.js

@@ -0,0 +1,85 @@
+import { McpError, McpErrorCode } from '../utils/McpErrorHandler.js';
+// Import utility tools
+import { HealthCheckController } from '../tools/utility/HealthCheckController.js';
+import { QuickstartTool } from '../tools/utility/QuickstartTool.js';
+import { AuthorIndexTool } from '../tools/utility/AuthorIndexTool.js';
+import { ListRepositoriesTool } from '../tools/utility/ListRepositoriesTool.js';
+// Import core tools
+import { GetArtifactTool } from '../tools/core/GetArtifactTool.js';
+import { GetChunkTool } from '../tools/core/GetChunkTool.js';
+import { PublishArtifactTool } from '../tools/core/PublishArtifactTool.js';
+import { PublishArtifactFromFileTool } from '../tools/core/PublishArtifactFromFileTool.js';
+import { ListArtifactsTool } from '../tools/core/ListArtifactsTool.js';
+import { DeleteArtifactTool } from '../tools/core/DeleteArtifactTool.js';
+import { GetArtifactVersionsTool } from '../tools/core/GetArtifactVersionsTool.js';
+export class ToolRegistry {
+    ucmClient;
+    logger;
+    trustedAuthors;
+    authorId;
+    tools = new Map();
+    constructor(ucmClient, logger, trustedAuthors = [], authorId) {
+        this.ucmClient = ucmClient;
+        this.logger = logger;
+        this.trustedAuthors = trustedAuthors;
+        this.authorId = authorId;
+        this.registerTools();
+    }
+    registerTools() {
+        // Register utility tools
+        this.registerTool(new QuickstartTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new HealthCheckController(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new AuthorIndexTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new ListRepositoriesTool(this.ucmClient, this.logger, this.authorId));
+        // Register core tools
+        this.registerTool(new GetArtifactTool(this.ucmClient, this.logger, this.authorId, this.trustedAuthors));
+        this.registerTool(new GetChunkTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new PublishArtifactFromFileTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new PublishArtifactTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new ListArtifactsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new DeleteArtifactTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GetArtifactVersionsTool(this.ucmClient, this.logger, this.authorId));
+        this.logger.info('ToolRegistry', `Registered ${this.tools.size} MCP tools`);
+    }
+    registerTool(tool) {
+        if (this.tools.has(tool.name)) {
+            this.logger.warn('ToolRegistry', `Tool ${tool.name} already registered, overwriting`);
+        }
+        this.tools.set(tool.name, tool);
+        this.logger.debug('ToolRegistry', `Registered tool: ${tool.name}`);
+    }
+    async listTools() {
+        const toolList = [];
+        for (const [, tool] of this.tools) {
+            toolList.push({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema
+            });
+        }
+        return toolList;
+    }
+    async executeTool(name, params) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            throw new McpError(McpErrorCode.MethodNotFound, `Tool '${name}' not found`);
+        }
+        this.logger.debug('ToolRegistry', `Executing tool: ${name}`);
+        try {
+            const result = await tool.execute(params);
+            this.logger.debug('ToolRegistry', `Tool ${name} completed successfully`);
+            return result;
+        }
+        catch (error) {
+            this.logger.error('ToolRegistry', `Tool ${name} execution failed`, '', error);
+            throw error;
+        }
+    }
+    getToolCount() {
+        return this.tools.size;
+    }
+    hasToolnamed(name) {
+        return this.tools.has(name);
+    }
+}
+//# sourceMappingURL=ToolRegistry.js.map

package/dist/tools/artifacts/GetArtifactController.d.ts

@@ -0,0 +1,34 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmApiClient } from '../../clients/UcmApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class GetArtifactController extends BaseToolController {
+    constructor(ucmClient: UcmApiClient, logger: ILogger);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected handleExecute(params: any): Promise<any>;
+    private buildArtifactResponse;
+    private enrichMetadata;
+    private processExamples;
+    private enrichDependencies;
+    private getVersionHistory;
+    private getRelatedArtifacts;
+    private detectContentType;
+    private detectLanguage;
+    private getIncludedSections;
+    private isLatestVersion;
+    private calculateQualityScore;
+    private estimateComplexity;
+    private assessMaturityLevel;
+    private sanitizeExternalDependencies;
+    private checkDependencyResolution;
+    private findMissingDependencies;
+    private detectDependencyConflicts;
+    private generateChangesSummary;
+    private isBreakingChange;
+    private getDownloadCount;
+    private calculateRating;
+    private getLastAccessTime;
+    private calculateSimilarity;
+}
+//# sourceMappingURL=GetArtifactController.d.ts.map