@utaba/ucm-mcp-server 4.2.2 → 4.3.0

package/dist/clients/UcmLocalApiClient.js

@@ -0,0 +1,460 @@
+import axios from 'axios';
+export class UcmLocalApiClient {
+    baseUrl;
+    authToken;
+    authorId;
+    organizationId;
+    client;
+    constructor(baseUrl, authToken, timeout = 600000, authorId, organizationId) {
+        this.baseUrl = baseUrl;
+        this.authToken = authToken;
+        this.authorId = authorId;
+        this.organizationId = organizationId;
+        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) => {
+            // For 4xx and 5xx errors, preserve the full error object so calling code
+            // can access error.response.data.details (e.g., for loginUrl in auth errors)
+            if (error.response && error.response.status >= 400) {
+                // Pass through the full axios error - don't wrap it
+                return Promise.reject(error);
+            }
+            // For other errors (network, timeout, etc.), 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;
+        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 searchArtifactsByText(searchParams) {
+        const params = new URLSearchParams();
+        // Add all parameters to URL
+        Object.entries(searchParams).forEach(([key, value]) => {
+            if (value !== undefined)
+                params.append(key, value.toString());
+        });
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/search/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]) => {
+                // Skip if value is undefined, null, empty string, or string "null"/"undefined"
+                if (value !== undefined && value !== null && value !== '' && value !== 'null' && value !== 'undefined') {
+                    // Handle arrays (e.g., tags) by JSON stringifying them
+                    if (Array.isArray(value)) {
+                        params.append(key, JSON.stringify(value));
+                    }
+                    else {
+                        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]) => {
+                // Skip if value is undefined, null, empty string, or string "null"/"undefined"
+                if (value !== undefined && value !== null && value !== '' && value !== 'null' && value !== 'undefined') {
+                    // Handle arrays (e.g., tags) by JSON stringifying them
+                    if (Array.isArray(value)) {
+                        params.append(key, JSON.stringify(value));
+                    }
+                    else {
+                        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;
+    }
+    async getAuthorRecents(author) {
+        const client = this.ensureClient();
+        // Author-level recent activity (using new resources API structure)
+        const url = `/api/v1/resources/author/${author}/recents`;
+        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;
+    }
+    // Repository Management Methods
+    async createRepository(author, data) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/authors/${author}`, data);
+        return response.data;
+    }
+    async getRepository(author, repository) {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/authors/${author}/${repository}`);
+        return response.data;
+    }
+    async updateRepository(author, repository, data) {
+        const client = this.ensureClient();
+        const response = await client.put(`/api/v1/authors/${author}/${repository}`, data);
+        return response.data;
+    }
+    async deleteRepository(author, repository) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/authors/${author}/${repository}`);
+        return response.data;
+    }
+    async listRepositories(author, 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();
+        const url = `/api/v1/authors/${author}${queryString ? `?${queryString}` : ''}`;
+        const client = this.ensureClient();
+        const response = await client.get(url);
+        return response.data;
+    }
+    async submitFeedback(data) {
+        const client = this.ensureClient();
+        const response = await client.post('/api/v1/feedback', data);
+        return response.data;
+    }
+    async editArtifactMetadata(author, repository, category, subcategory, filename, data) {
+        const client = this.ensureClient();
+        const url = this.buildApiPath('authors', author, repository, category, subcategory, filename) + '/edit';
+        // Transform updateTags from comma-separated string to array for API
+        const requestData = { ...data };
+        if (data.updateTags && typeof data.updateTags === 'string') {
+            // Parse comma-separated tags into array, trim whitespace, filter empty strings
+            requestData.updateTags = data.updateTags
+                .split(',')
+                .map(tag => tag.trim())
+                .filter(tag => tag.length > 0);
+        }
+        const response = await client.post(url, requestData);
+        return response.data;
+    }
+    // SharePoint API methods
+    /**
+     * List External Connections including SharePoint
+     * Returns markdown with a table of connections available
+     */
+    async listExternalConnections(params) {
+        const client = this.ensureClient();
+        const url = `/api/v1/connections`;
+        const response = await client.get(url, { params });
+        return response.data;
+    }
+    /**
+     * Search SharePoint documents using Microsoft Search API
+     * Uses V1 API - organizationId is auto-detected from auth token
+     */
+    async sharePointSearch(connectionId, params) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/connections/sharepoint/search`, {
+            connectionId,
+            ...params
+        });
+        return response.data;
+    }
+    /**
+     * List folders and files in SharePoint with pagination
+     * Uses V1 API - organizationId is auto-detected from auth token
+     */
+    async sharePointListFolders(connectionId, params) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/connections/sharepoint/folders`, {
+            connectionId,
+            ...params
+        });
+        return response.data;
+    }
+    /**
+     * Read SharePoint file content with support for both fileUrl and legacy fileId
+     * Uses V1 API - organizationId is auto-detected from auth token
+     */
+    async sharePointReadFile(connectionId, params) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/connections/sharepoint/read`, {
+            connectionId,
+            ...params
+        });
+        return response.data;
+    }
+    /**
+     * Read SharePoint related file (image/embedded file extracted from document)
+     * Uses V1 API - organizationId is auto-detected from auth token
+     * Accepts full URI from markdown (with or without protocol prefix)
+     * Returns complete file content (no pagination support)
+     */
+    async sharePointReadRelatedFile(uri) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/connections/sharepoint/related-file`, { uri }, // Pass URI in JSON body
+        {
+            responseType: 'arraybuffer' // Binary data
+        });
+        // Convert binary response to base64 for MCP transport
+        const base64Content = Buffer.from(response.data).toString('base64');
+        const contentType = response.headers['content-type'] || 'application/octet-stream';
+        const contentLength = parseInt(response.headers['content-length'] || '0', 10);
+        // Extract fileName from URI for response metadata
+        const fileName = this.extractFileNameFromUri(uri);
+        return {
+            fileName,
+            mimeType: contentType,
+            size: contentLength,
+            content: base64Content
+        };
+    }
+    /**
+     * Extract fileName from SharePoint related file URI
+     * Helper method for metadata purposes
+     */
+    extractFileNameFromUri(uri) {
+        // Strip protocol prefix if present
+        const cleaned = uri.replace(/^ucm_sharepoint_read_relatedfile:\/\//, '');
+        // Extract path portion before query string
+        const pathPart = cleaned.split('?')[0];
+        // URL-decode the fileName
+        return decodeURIComponent(pathPart);
+    }
+    /**
+     * Revoke SharePoint OnBehalfOf authorization for a connection
+     * Deletes user's access tokens from Key Vault and database
+     * Uses V1 API - organizationId is auto-detected from auth token
+     */
+    async sharePointSignOut(connectionId) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/connections/sharepoint/signout`, { connectionId });
+        return response.data;
+    }
+}
+//# sourceMappingURL=UcmLocalApiClient.js.map

package/dist/index.js

@@ -12,12 +12,12 @@ async function main() {
     program
         .name('ucm-mcp-server')
         .description('Universal Context Manager - Read the ucm_connect tool first to avoid mistakes')
-        .version('4.1.0')
+        .version('1.0.5')
         .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('--ca-cert <path>', 'Path to CA certificate file (PEM format) for self-signed certificates')
+        .option('--trusted-authors <authors>', 'Comma-separated list of trusted authors (e.g., "utaba,{anotherauthor}")', "utaba")
         .parse();
     const options = program.opts();
     const config = new McpConfig({
@@ -25,8 +25,7 @@ async function main() {
         port: parseInt(options.port),
         logLevel: options.logLevel,
         authToken: options.authToken,
-        trustedAuthors: options.trustedAuthors ? options.trustedAuthors.split(',').map((a) => a.trim()) : ["utaba"],
-        caCertPath: options.caCert
+        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);

package/dist/server/McpConfig.d.ts

@@ -6,7 +6,6 @@ export interface McpServerConfig {
     logLevel: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
     requestTimeout: number;
     trustedAuthors: string[];
-    caCertPath?: string;
 }
 export declare class McpConfig {
     private config;
@@ -22,7 +21,6 @@ export declare class McpConfig {
     get requestTimeout(): number;
     get trustedAuthors(): string[];
     get authorId(): string | undefined;
-    get caCertPath(): string | undefined;
     getFullConfig(): McpServerConfig;
 }
 //# sourceMappingURL=McpConfig.d.ts.map

package/dist/server/McpConfig.js

@@ -12,8 +12,7 @@ export class McpConfig {
             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', '')),
-            caCertPath: options.caCertPath
+            trustedAuthors: options.trustedAuthors || this.parseTrustedAuthors(this.getEnvVar('MCP_TRUSTED_AUTHORS', ''))
         };
         this.validateConfig();
     }
@@ -83,9 +82,6 @@ export class McpConfig {
     get authorId() {
         return this.config.authorId;
     }
-    get caCertPath() {
-        return this.config.caCertPath;
-    }
     // Get full configuration object (for testing and debugging)
     getFullConfig() {
         return { ...this.config };

package/dist/server/McpServer.js

@@ -2,9 +2,8 @@ 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/UcmApiClient.js';
+import { UcmLocalApiClient } from '../clients/UcmLocalApiClient.js';
 import { ToolRegistry } from './ToolRegistry.js';
-import { HttpsAgentFactory } from '../utils/HttpsAgentFactory.js';
 export class McpServer {
     config;
     logger;
@@ -15,11 +14,7 @@ export class McpServer {
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
-        // Create HTTPS agent with custom CA certificate if provided
-        const httpsAgent = config.caCertPath
-            ? HttpsAgentFactory.createAgent({ caCertPath: config.caCertPath }, logger)
-            : undefined;
-        this.ucmClient = new UcmLocalApiClient(config.ucmApiUrl, config.authToken, config.requestTimeout, config.authorId, httpsAgent);
+        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({

package/dist/server/ToolRegistry.js

@@ -21,6 +21,13 @@ import { CreateRepositoryTool } from '../tools/repository/CreateRepositoryTool.j
 import { GetRepositoryTool } from '../tools/repository/GetRepositoryTool.js';
 import { UpdateRepositoryTool } from '../tools/repository/UpdateRepositoryTool.js';
 import { DeleteRepositoryGuidanceTool } from '../tools/repository/DeleteRepositoryGuidanceTool.js';
+// Import SharePoint tools
+import { SharePointListConnectionsTool as ListConnectionsTool } from '../tools/sharepoint/SharePointListConnectionsTool.js';
+import { SharePointSearchTool } from '../tools/sharepoint/SharePointSearchTool.js';
+import { SharePointListFoldersTool } from '../tools/sharepoint/SharePointListFoldersTool.js';
+import { SharePointReadFileTool } from '../tools/sharepoint/SharePointReadFileTool.js';
+import { SharePointReadRelatedFileTool } from '../tools/sharepoint/SharePointReadRelatedFileTool.js';
+import { SharePointSignOutTool } from '../tools/sharepoint/SharePointSignOutTool.js';
 export class ToolRegistry {
     ucmClient;
     logger;
@@ -59,6 +66,13 @@ export class ToolRegistry {
         this.registerTool(new GetRepositoryTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new UpdateRepositoryTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new DeleteRepositoryGuidanceTool(this.ucmClient, this.logger, this.authorId, this.baseUrl));
+        // Register SharePoint tools
+        this.registerTool(new ListConnectionsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new SharePointSearchTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new SharePointListFoldersTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new SharePointReadFileTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new SharePointReadRelatedFileTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new SharePointSignOutTool(this.ucmClient, this.logger, this.authorId));
         this.logger.info('ToolRegistry', `Registered ${this.tools.size} MCP tools`);
     }
     registerTool(tool) {

package/dist/tools/repository/CreateRepositoryTool.js

@@ -8,7 +8,7 @@ export class CreateRepositoryTool extends BaseToolController {
         return 'ucm_create_repository';
     }
     get description() {
-        const authorInfo = this.publishingAuthorId ? ` Your author id is '${this.publishingAuthorId}'.` : '';
+        const authorInfo = this.publishingAuthorId ? ` Your author default author id is '${this.publishingAuthorId}'.` : '';
         return `Create a new repository for a specific author. Repository names must be unique within the author namespace and follow UCM naming conventions. (3-200 characters, start with letter, alphanumeric and hyphens only, no consecutive hyphens).${authorInfo}`;
     }
     get inputSchema() {
@@ -37,11 +37,6 @@ export class CreateRepositoryTool extends BaseToolController {
                     type: 'string',
                     description: 'Repository description (optional)',
                     maxLength: 1000
-                },
-                isPublic: {
-                    type: 'boolean',
-                    description: 'Whether the repository is public (defaults to false, public repositories not yet supported)',
-                    default: false
                 }
             },
             required: ['author', 'repositoryName'],
@@ -74,10 +69,6 @@ export class CreateRepositoryTool extends BaseToolController {
         if (params.description && params.description.length > 1000) {
             throw new McpError(McpErrorCode.InvalidParams, 'Description cannot exceed 1,000 characters');
         }
-        // Validate isPublic - public repositories are not yet supported
-        if (params.isPublic === true) {
-            throw new McpError(McpErrorCode.InvalidParams, 'Public repositories are not yet supported. Set isPublic to false or omit the parameter.');
-        }
     }
     async handleExecute(params) {
         this.logger.info('CreateRepositoryTool', `Creating repository ${params.repositoryName} for author ${params.author}`);
@@ -85,8 +76,7 @@ export class CreateRepositoryTool extends BaseToolController {
             const repositoryData = {
                 repositoryName: params.repositoryName,
                 displayName: params.displayName,
-                description: params.description,
-                isPublic: params.isPublic || false
+                description: params.description
             };
             const result = await this.ucmClient.createRepository(params.author, repositoryData);
             this.logger.info('CreateRepositoryTool', `Repository created successfully: ${params.repositoryName}`);

package/dist/tools/repository/UpdateRepositoryTool.js

@@ -8,8 +8,8 @@ export class UpdateRepositoryTool extends BaseToolController {
         return 'ucm_update_repository';
     }
     get description() {
-        const authorInfo = this.publishingAuthorId ? ` Your author id is '${this.publishingAuthorId}'.` : '';
-        return `Update repository metadata including display name, description, and visibility settings. Note: Repository names cannot be changed after creation as they serve as permanent identifiers in the namespace path.${authorInfo}`;
+        const authorInfo = this.publishingAuthorId ? ` Your default author id is '${this.publishingAuthorId}'.` : '';
+        return `Update repository metadata including display name and description.${authorInfo}`;
     }
     get inputSchema() {
         return {
@@ -36,10 +36,6 @@ export class UpdateRepositoryTool extends BaseToolController {
                     type: 'string',
                     description: 'New repository description (optional)',
                     maxLength: 1000
-                },
-                isPublic: {
-                    type: 'boolean',
-                    description: 'Whether the repository should be public (currently not supported, must be false)'
                 }
             },
             required: ['author', 'repository'],
@@ -55,10 +51,10 @@ export class UpdateRepositoryTool extends BaseToolController {
             throw new McpError(McpErrorCode.InvalidParams, 'Repository name is required and cannot be empty');
         }
         // Validate at least one field to update is provided
-        const updateFields = ['displayName', 'description', 'isPublic'];
+        const updateFields = ['displayName', 'description'];
         const hasUpdateField = updateFields.some(field => params[field] !== undefined);
         if (!hasUpdateField) {
-            throw new McpError(McpErrorCode.InvalidParams, 'At least one field to update must be provided (displayName, description, or isPublic)');
+            throw new McpError(McpErrorCode.InvalidParams, 'At least one field to update must be provided (displayName or description)');
         }
         // Validate displayName length if provided
         if (params.displayName !== undefined && params.displayName.length > 255) {
@@ -68,10 +64,6 @@ export class UpdateRepositoryTool extends BaseToolController {
         if (params.description !== undefined && params.description.length > 1000) {
             throw new McpError(McpErrorCode.InvalidParams, 'Description cannot exceed 1,000 characters');
         }
-        // Validate isPublic - public repositories are not yet supported
-        if (params.isPublic === true) {
-            throw new McpError(McpErrorCode.InvalidParams, 'Public repositories are not yet supported. Set isPublic to false or omit the parameter.');
-        }
     }
     async handleExecute(params) {
         this.logger.info('UpdateRepositoryTool', `Updating repository ${params.repository} for author ${params.author}`);
@@ -84,9 +76,6 @@ export class UpdateRepositoryTool extends BaseToolController {
             if (params.description !== undefined) {
                 updateData.description = params.description;
             }
-            if (params.isPublic !== undefined) {
-                updateData.isPublic = params.isPublic;
-            }
             const result = await this.ucmClient.updateRepository(params.author, params.repository, updateData);
             this.logger.info('UpdateRepositoryTool', `Repository updated successfully: ${params.repository}`);
             return {