@utaba/ucm-mcp-server 1.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Utaba AI
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,79 @@
+# UCM MCP Server
+
+Universal Context Manager (UCM) Model Context Protocol (MCP) server for AI-native package management.
+
+## Installation
+
+```bash
+# Global installation (recommended)
+npm install -g ucm-mcp-server
+
+# Or using the scoped package
+npm install -g @utaba/ucm-mcp-server
+```
+
+## Quick Start
+
+```bash
+# Start the MCP server
+ucm-mcp-server --ucm-url https://ucm.utaba.ai --auth-token YOUR_AUTH_TOKEN
+```
+
+Get your auth token from https://ucm.utaba.ai
+
+## Configuration
+
+The UCM MCP server requires the following parameters:
+
+- `--ucm-url <url>` (required): UCM API base URL
+- `--auth-token <token>` (required): Authentication token in format `{authorid}:{apikey}`
+
+## Available MCP Tools
+
+The server provides 11 MCP tools following the `mcp_ucm_` naming convention:
+
+### System Tools
+- `mcp_ucm_health_check` - Check MCP server and UCM API connectivity
+- `mcp_ucm_quickstart` - Get the UCM quickstart guide
+
+### Discovery Tools
+- `mcp_ucm_get_author_index` - Generate dynamic markdown index for an author
+- `mcp_ucm_list_repositories` - List all repositories for an author
+- `mcp_ucm_list_artifacts` - Browse the 4-level hierarchy
+
+### Artifact Management
+- `mcp_ucm_get_artifact` - Retrieve artifact content with auto-chunking
+- `mcp_ucm_get_chunk` - Get chunks of large responses
+- `mcp_ucm_publish_artifact` - Create/update artifacts
+- `mcp_ucm_publish_artifact_fromfile` - File-based publishing (preferred for large files)
+- `mcp_ucm_delete_artifact` - Remove artifacts
+- `mcp_ucm_get_artifact_versions` - Get version history
+
+## Usage with Claude Desktop
+
+Add to your Claude Desktop configuration:
+
+```json
+{
+  "mcpServers": {
+    "ucm": {
+      "command": "npx",
+      "args": [
+        "ucm-mcp-server",
+        "--ucm-url", "https://ucm.utaba.ai",
+        "--auth-token", "YOUR_AUTH_TOKEN"
+      ]
+    }
+  }
+}
+```
+
+## Documentation
+
+For detailed documentation, visit:
+- UCM Platform: https://ucm.utaba.ai
+- GitHub: https://github.com/utaba/ucm-mcp-server
+
+## License
+
+MIT - See LICENSE file for details

package/dist/clients/UcmApiClient.d.ts

@@ -0,0 +1,53 @@
+import { ArtifactData, AuthorData } from '../types/UcmApiTypes.js';
+export declare class UcmApiClient {
+    private baseUrl;
+    private authToken?;
+    private authorId?;
+    private client;
+    constructor(baseUrl: string, authToken?: string | undefined, timeout?: number, authorId?: string | undefined);
+    private setupInterceptors;
+    private ensureClient;
+    getAuthors(): Promise<AuthorData[]>;
+    getAuthor(authorId: string): Promise<AuthorData | null>;
+    private buildApiPath;
+    getArtifact(author?: string, repository?: string, category?: string, subcategory?: string, filename?: string, version?: string): Promise<ArtifactData>;
+    getLatestArtifact(author?: string, repository?: string, category?: string, subcategory?: string, filename?: string): Promise<ArtifactData>;
+    listArtifacts(author?: string, repository?: string, category?: string, subcategory?: string, offset?: number, limit?: number): Promise<{
+        data: any[];
+        pagination: {
+            offset: number;
+            limit: number;
+            total: number;
+        };
+        _links?: any;
+    }>;
+    searchArtifacts(filters?: {
+        repository?: string;
+        category?: string;
+        technology?: string;
+        subcategory?: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<ArtifactData[]>;
+    publishArtifact(author: string, repository: string, category: string, subcategory: string, data: any): Promise<ArtifactData>;
+    updateArtifact(author: string, repository: string, category: string, subcategory: string, filename: string, version: string, data: any): Promise<ArtifactData>;
+    deleteArtifact(author: string, repository: string, category: string, subcategory: string, filename: string, version?: string): Promise<any>;
+    getArtifactVersions(author: string, repository: string, category: string, subcategory: string, filename: string): Promise<any>;
+    getCategories(): Promise<string[]>;
+    healthCheck(): Promise<{
+        status: string;
+        timestamp: string;
+    }>;
+    getQuickstart(): Promise<string>;
+    getAuthorIndex(author: string, repository?: string): Promise<string>;
+    /**
+     * Cleanup method to properly dispose of HTTP client resources
+     * This helps prevent memory leaks from accumulated AbortSignal listeners
+     */
+    cleanup(): void;
+    /**
+     * Check if the client is still available for use
+     */
+    isAvailable(): boolean;
+}
+//# sourceMappingURL=UcmApiClient.d.ts.map

package/dist/clients/UcmApiClient.js

@@ -0,0 +1,297 @@
+import axios from 'axios';
+export class UcmApiClient {
+    baseUrl;
+    authToken;
+    authorId;
+    client;
+    constructor(baseUrl, authToken, timeout = 600000, authorId) {
+        this.baseUrl = baseUrl;
+        this.authToken = authToken;
+        this.authorId = authorId;
+        this.client = axios.create({
+            baseURL: this.baseUrl,
+            timeout,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(authToken && { 'Authorization': `Bearer ${authToken}` })
+            }
+        });
+        this.setupInterceptors();
+    }
+    setupInterceptors() {
+        this.client.interceptors.response.use((response) => response, (error) => {
+            // Extract error details from API response if available
+            const apiError = error.response?.data;
+            const status = error.response?.status;
+            const url = error.config?.url;
+            const errorMessage = apiError?.message || apiError?.error || error.message || JSON.stringify(apiError);
+            if (status === 404) {
+                return Promise.reject(new Error(`Resource not found: ${errorMessage}`));
+            }
+            if (status >= 500) {
+                // For 5xx errors, include API error details if available
+                return Promise.reject(new Error(`UCM API server error: ${errorMessage}`));
+            }
+            if (status >= 400 && status < 500) {
+                // For 4xx errors, extract validation details from API response
+                if (apiError?.message) {
+                    return Promise.reject(new Error(apiError.message));
+                }
+                if (apiError?.error) {
+                    return Promise.reject(new Error(apiError.error));
+                }
+                if (apiError?.errors && Array.isArray(apiError.errors)) {
+                    return Promise.reject(new Error(apiError.errors.join(', ')));
+                }
+                // Fallback to JSON stringify the entire API error response
+                return Promise.reject(new Error(errorMessage));
+            }
+            // For other errors, preserve original error
+            return Promise.reject(error);
+        });
+    }
+    ensureClient() {
+        if (!this.client) {
+            throw new Error('UcmApiClient has been cleaned up and is no longer available');
+        }
+        return this.client;
+    }
+    async getAuthors() {
+        const client = this.ensureClient();
+        const response = await client.get('/api/v1/authors');
+        return response.data;
+    }
+    async getAuthor(authorId) {
+        // No individual author endpoint - get from authors list
+        const authors = await this.getAuthors();
+        return authors.find(author => author.id === authorId) || null;
+    }
+    buildApiPath(api, author, repository, category, subcategory, filename, version) {
+        let path = `/api/v1/${api}`;
+        if (author) {
+            path += `/${author}`;
+        }
+        else {
+            return path;
+        }
+        if (repository) {
+            path += `/${repository}`;
+        }
+        else {
+            return path;
+        }
+        if (category) {
+            path += `/${category}`;
+        }
+        else {
+            return path;
+        }
+        if (subcategory) {
+            path += `/${subcategory}`;
+        }
+        else {
+            return path;
+        }
+        if (filename) {
+            path += `/${filename}`;
+        }
+        else {
+            return path;
+        }
+        if (version) {
+            path += `@${version}`;
+        }
+        else {
+            return path;
+        }
+        return path;
+    }
+    async getArtifact(author, repository, category, subcategory, filename, version) {
+        // Default repository to 'main' for MVP
+        const repo = repository || 'main';
+        let metadataApiPath = this.buildApiPath('authors', author, repo, category, subcategory, filename, version);
+        // First get metadata from authors endpoint
+        const client = this.ensureClient();
+        const metadataResponse = await client.get(metadataApiPath);
+        const metadata = metadataResponse.data;
+        if (filename) {
+            let fileApiPath = this.buildApiPath('files', author, repo, category, subcategory, filename, version);
+            // Then get actual file content from files endpoint
+            let contentResponse = await client.get(fileApiPath, {
+                headers: { 'accept': metadataResponse.data }
+            });
+            return {
+                ...metadata.data,
+                content: contentResponse.data
+            };
+        }
+        // Combine metadata and content
+        return {
+            ...metadata.data,
+        };
+    }
+    async getLatestArtifact(author, repository, category, subcategory, filename) {
+        // Default repository to 'main' for MVP
+        const repo = repository || 'main';
+        let metadataApiPath = this.buildApiPath('authors', author, repo, category, subcategory, filename);
+        const client = this.ensureClient();
+        const response = await client.get(metadataApiPath);
+        return response.data;
+    }
+    async listArtifacts(author, repository, category, subcategory, offset, limit) {
+        const params = new URLSearchParams();
+        if (offset !== undefined)
+            params.append('offset', offset.toString());
+        if (limit !== undefined)
+            params.append('limit', limit.toString());
+        const queryString = params.toString();
+        // Build URL based on provided parameters for exploratory browsing
+        // Default repository to 'main' for MVP
+        const repo = repository || 'main';
+        let metadataApiPath = this.buildApiPath('authors', author, repo, category, subcategory);
+        metadataApiPath += queryString ? `?${queryString}` : '';
+        const client = this.ensureClient();
+        const response = await client.get(metadataApiPath);
+        return response.data; // response.data contains the full structured response with pagination
+    }
+    async searchArtifacts(filters = {}) {
+        const params = new URLSearchParams();
+        // Default repository to 'main' for MVP if not specified
+        if (!filters.repository) {
+            filters.repository = 'main';
+        }
+        Object.entries(filters).forEach(([key, value]) => {
+            if (value !== undefined)
+                params.append(key, value.toString());
+        });
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/artifacts?${params}`);
+        return response.data;
+    }
+    async publishArtifact(author, repository, category, subcategory, data) {
+        // Default repository to 'main' for MVP
+        const repo = repository || 'main';
+        // Build query parameters from the data object
+        const params = new URLSearchParams();
+        if (data.queryParams) {
+            // New API structure with query params
+            Object.entries(data.queryParams).forEach(([key, value]) => {
+                if (value !== undefined && value !== null && value !== '') {
+                    params.append(key, String(value));
+                }
+            });
+            // Send raw content as text/plain body
+            const client = this.ensureClient();
+            const response = await client.post(`/api/v1/authors/${author}/${repo}/${category}/${subcategory}?${params.toString()}`, data.content, {
+                headers: {
+                    'Content-Type': 'text/plain'
+                }
+            });
+            return response.data;
+        }
+        else {
+            // Legacy API structure (for backward compatibility)
+            const client = this.ensureClient();
+            const response = await client.post(`/api/v1/authors/${author}/${repo}/${category}/${subcategory}`, data);
+            return response.data;
+        }
+    }
+    async updateArtifact(author, repository, category, subcategory, filename, version, data) {
+        // Default repository to 'main' for MVP
+        const repo = repository || 'main';
+        // Build query parameters from the data object
+        const params = new URLSearchParams();
+        if (data.queryParams) {
+            // New API structure with query params
+            Object.entries(data.queryParams).forEach(([key, value]) => {
+                if (value !== undefined && value !== null && value !== '') {
+                    params.append(key, String(value));
+                }
+            });
+            // Send raw content as text/plain body
+            const client = this.ensureClient();
+            const response = await client.put(`/api/v1/authors/${author}/${repo}/${category}/${subcategory}/${filename}@${version}?${params.toString()}`, data.content, {
+                headers: {
+                    'Content-Type': 'text/plain'
+                }
+            });
+            return response.data;
+        }
+        else {
+            // Legacy API structure (for backward compatibility)
+            const client = this.ensureClient();
+            const response = await client.put(`/api/v1/authors/${author}/${repo}/${category}/${subcategory}/${filename}@${version}`, data);
+            return response.data;
+        }
+    }
+    async deleteArtifact(author, repository, category, subcategory, filename, version) {
+        // Default repository to 'main' for MVP
+        const repo = repository || 'main';
+        const url = version
+            ? `/api/v1/authors/${author}/${repo}/${category}/${subcategory}/${filename}@${version}`
+            : `/api/v1/authors/${author}/${repo}/${category}/${subcategory}/${filename}`;
+        const client = this.ensureClient();
+        const response = await client.delete(url);
+        return response.data;
+    }
+    async getArtifactVersions(author, repository, category, subcategory, filename) {
+        // Default repository to 'main' for MVP
+        const repo = repository || 'main';
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/authors/${author}/${repo}/${category}/${subcategory}/${filename}/versions`);
+        return response.data;
+    }
+    async getCategories() {
+        // Categories are derived from artifacts since there's no dedicated endpoint
+        // Return the standard UCM categories
+        return ['commands', 'services', 'patterns', 'implementations', 'contracts', 'guidance', 'project'];
+    }
+    async healthCheck() {
+        const client = this.ensureClient();
+        const response = await client.get('/api/v1/health');
+        return response.data;
+    }
+    async getQuickstart() {
+        const client = this.ensureClient();
+        const response = await client.get('/api/v1/quickstart', {
+            headers: { 'accept': 'text/markdown' }
+        });
+        return response.data;
+    }
+    async getAuthorIndex(author, repository) {
+        const client = this.ensureClient();
+        let url;
+        if (repository) {
+            // Repository-specific index (future use)
+            url = `/api/v1/authors/${author}/${repository}/index`;
+        }
+        else {
+            // Author-level index
+            url = `/api/v1/authors/${author}/index`;
+        }
+        const response = await client.get(url, {
+            headers: { 'accept': 'text/markdown' }
+        });
+        return response.data;
+    }
+    /**
+     * Cleanup method to properly dispose of HTTP client resources
+     * This helps prevent memory leaks from accumulated AbortSignal listeners
+     */
+    cleanup() {
+        if (this.client) {
+            // Clear interceptors to remove event listeners
+            this.client.interceptors.request.clear();
+            this.client.interceptors.response.clear();
+            // Set client to null to let GC handle cleanup
+            this.client = null;
+        }
+    }
+    /**
+     * Check if the client is still available for use
+     */
+    isAvailable() {
+        return this.client !== null;
+    }
+}
+//# sourceMappingURL=UcmApiClient.js.map

package/dist/index.d.ts

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

package/dist/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 = 20;
+async function main() {
+    const program = new Command();
+    program
+        .name('ucm-mcp-server')
+        .description('Universal Context Manager - Read the mcp_ucm_quickstart first to avoid mistakes')
+        .version('1.0.0')
+        .requiredOption('-u, --ucm-url <url>', 'UCM API base URL')
+        .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/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/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/interfaces/IMcpTool.d.ts

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

package/dist/interfaces/IMcpTool.js

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

package/dist/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/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/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/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/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