@utaba/ucm-mcp-server 6.5.0 → 6.6.0

package/dist/mcp-server/clients/UcmLocalApiClient.js

@@ -0,0 +1,719 @@
+import axios from 'axios';
+export class UcmLocalApiClient {
+    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) => {
+            // 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;
+    }
+    /**
+     * Access a specific external connection
+     * Returns connection details, auth status, and available tool schemas
+     * Connection type is auto-detected by the server from the connectionId
+     */
+    async accessConnection(connectionId, toolNames) {
+        const client = this.ensureClient();
+        const params = {};
+        if (toolNames && toolNames.length > 0) {
+            params.toolNames = toolNames.join(',');
+        }
+        const response = await client.get(`/api/v1/connections/${connectionId}`, { params });
+        return response.data;
+    }
+    /**
+     * Call a tool on an external connection
+     * Executes a tool on a SharePoint connection or Remote MCP Server
+     * Connection type is auto-detected by the server from the connectionId
+     */
+    async callRemoteTool(connectionId, toolName, args) {
+        const client = this.ensureClient();
+        const body = { toolName };
+        if (args !== undefined) {
+            body.args = args;
+        }
+        const response = await client.post(`/api/v1/connections/${connectionId}/tools`, body);
+        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
+     * @deprecated Use signOut with connectionType='sharepoint' instead
+     */
+    async sharePointSignOut(connectionId) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/connections/sharepoint/signout`, { connectionId });
+        return response.data;
+    }
+    /**
+     * Unified OAuth sign out for any connection type
+     * Revokes user's OAuth authorization by deleting tokens from Key Vault and database
+     * @param connectionType - Type of connection: 'sharepoint' | 'remote-mcp'
+     * @param connectionId - Connection ID to revoke authorization for
+     */
+    async signOut(connectionType, connectionId) {
+        const client = this.ensureClient();
+        // Route to appropriate endpoint based on connection type
+        if (connectionType === 'sharepoint') {
+            const response = await client.post(`/api/v1/connections/sharepoint/signout`, { connectionId });
+            return response.data;
+        }
+        else if (connectionType === 'remote-mcp') {
+            // Remote MCP uses the oauth signout endpoint
+            const response = await client.post(`/api/v1/oauth/signout`, { connectionType, connectionId });
+            return response.data;
+        }
+        throw new Error(`Unsupported connection type: ${connectionType}`);
+    }
+    /**
+     * List all user's active OAuth authorizations
+     * @param connectionType - Optional filter: 'sharepoint' | 'remote-mcp' | 'all' (default: 'all')
+     */
+    async listAuthorizations(connectionType) {
+        const client = this.ensureClient();
+        const params = connectionType && connectionType !== 'all' ? { connectionType } : {};
+        const response = await client.get('/api/v1/oauth/authorizations', { params });
+        return response.data;
+    }
+    // ─── Memory Graph API Methods ───────────────────────────────────────
+    /**
+     * List memory graphs, optionally filtered by scope
+     * @param scope - 'organization' | 'personal' | 'all' (default: 'all')
+     */
+    async listMemoryGraphs(scope) {
+        const client = this.ensureClient();
+        const params = {};
+        if (scope && scope !== 'all') {
+            params.scope = scope;
+        }
+        const response = await client.get(`/api/v1/memory-graphs`, { params });
+        return response.data;
+    }
+    /**
+     * Create a new Memory Graph for the authenticated user
+     */
+    async createMemoryGraph(data) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs`, data);
+        return response.data;
+    }
+    /**
+     * List available vocabulary templates for Memory Graph creation
+     */
+    async listMemoryGraphTemplates() {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/memory-graphs/templates`);
+        return response.data;
+    }
+    /**
+     * Semantic vector search across multiple Memory Graphs
+     */
+    async graphSearchMultiple(query, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/search`, {
+            query,
+            ...options
+        });
+        return response.data;
+    }
+    /**
+     * List knowledge sets for an organization
+     */
+    async listKnowledgeSets() {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/knowledge-sets`);
+        return response.data;
+    }
+    /**
+     * List knowledge set summary (markdown) for an organization
+     */
+    async listKnowledgeSetSummary() {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/knowledge-sets/summary`);
+        return response.data.markdown;
+    }
+    /**
+     * Open a knowledge set — returns markdown summary with contents and tool guidance
+     */
+    async openKnowledgeSet(knowledgeSetId) {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/knowledge-sets/${knowledgeSetId}/summary`);
+        return response.data.markdown;
+    }
+    /**
+     * Open a memory graph — returns vocabulary, stats, instructions, policies, and metadata
+     */
+    async graphOpen(graphId) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/open`);
+        return response.data;
+    }
+    /**
+     * Find entities with filters and pagination
+     */
+    async graphFindEntities(graphId, query) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/entities/find`, query);
+        return response.data;
+    }
+    /**
+     * Get a single entity by ID
+     */
+    async graphGetEntity(graphId, entityId, detailLevel) {
+        const client = this.ensureClient();
+        const params = {};
+        if (detailLevel)
+            params.detailLevel = detailLevel;
+        const response = await client.get(`/api/v1/memory-graphs/${graphId}/entities/${entityId}`, { params });
+        return response.data;
+    }
+    /**
+     * Get relationships for an entity
+     */
+    async graphGetRelationships(graphId, entityId, options) {
+        const client = this.ensureClient();
+        const params = {};
+        if (options?.direction)
+            params.direction = options.direction;
+        if (options?.relationshipTypes)
+            params.relationshipTypes = options.relationshipTypes.join(',');
+        if (options?.limit)
+            params.limit = String(options.limit);
+        const response = await client.get(`/api/v1/memory-graphs/${graphId}/entities/${entityId}/relationships`, { params });
+        return response.data;
+    }
+    /**
+     * Explore neighbourhood around an entity (BFS, 1-3 hops)
+     */
+    async graphExplore(graphId, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/explore`, options);
+        return response.data;
+    }
+    /**
+     * Find paths between two entities
+     */
+    async graphFindPaths(graphId, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/find-paths`, options);
+        return response.data;
+    }
+    /**
+     * Structured graph traversal with a JSON spec
+     */
+    async graphTraverse(graphId, spec) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/traverse`, spec);
+        return response.data;
+    }
+    /**
+     * Semantic vector search on entity embeddings
+     */
+    async graphSearch(graphId, query, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/search`, {
+            query,
+            ...options
+        });
+        return response.data;
+    }
+    /**
+     * Create one or more entities
+     */
+    async graphCreateEntities(graphId, entities) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/entities`, { entities });
+        return response.data;
+    }
+    /**
+     * Update one or more entities
+     */
+    async graphUpdateEntities(graphId, updates) {
+        const client = this.ensureClient();
+        const response = await client.put(`/api/v1/memory-graphs/${graphId}/entities`, { updates });
+        return response.data;
+    }
+    /**
+     * Delete one or more entities
+     */
+    async graphDeleteEntities(graphId, entityIds) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/memory-graphs/${graphId}/entities`, {
+            data: { entityIds }
+        });
+        return response.data;
+    }
+    /**
+     * Create one or more relationships
+     */
+    async graphCreateRelationships(graphId, relationships) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/relationships`, { relationships });
+        return response.data;
+    }
+    /**
+     * Delete one or more relationships
+     */
+    async graphDeleteRelationships(graphId, relationshipIds) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/memory-graphs/${graphId}/relationships`, {
+            data: { relationshipIds }
+        });
+        return response.data;
+    }
+    /**
+     * Delete an entire memory graph (SQL record + CosmosDB repository)
+     */
+    async graphDelete(graphId) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/memory-graphs/${graphId}`);
+        return response.data;
+    }
+    /**
+     * Propose vocabulary extensions (entity types / relationship types)
+     */
+    async graphProposeVocabulary(graphId, proposals) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/vocabulary/propose`, proposals);
+        return response.data;
+    }
+}
+//# sourceMappingURL=UcmLocalApiClient.js.map