@utaba/ucm-mcp-server 6.5.0 → 6.6.0

package/dist/mcp-server/clients/UcmLocalApiClient.d.ts

@@ -0,0 +1,399 @@
+import { ArtifactData, AuthorData } from '../types/UcmApiTypes.js';
+export declare class UcmLocalApiClient {
+    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[]>;
+    searchArtifactsByText(searchParams: {
+        searchText?: string;
+        namespace?: string;
+        author?: string;
+        repository?: string;
+        category?: string;
+        subcategory?: string;
+        filename?: string;
+        tags?: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<{
+        data: any[];
+        pagination: {
+            offset: number;
+            limit: number;
+            total: number;
+            hasMore: boolean;
+        };
+        _links?: any;
+    }>;
+    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>;
+    getAuthorRecents(author: 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;
+    createRepository(author: string, data: {
+        repositoryName: string;
+        displayName?: string;
+        description?: string;
+    }): Promise<any>;
+    getRepository(author: string, repository: string): Promise<any>;
+    updateRepository(author: string, repository: string, data: {
+        displayName?: string;
+        description?: string;
+    }): Promise<any>;
+    deleteRepository(author: string, repository: string): Promise<any>;
+    listRepositories(author: string, offset?: number, limit?: number): Promise<{
+        data: any[];
+        pagination: {
+            offset: number;
+            limit: number;
+            total: number;
+        };
+        _links?: any;
+    }>;
+    submitFeedback(data: {
+        title: string;
+        body: string;
+        reportType: 'issue' | 'feedback';
+        tags?: string;
+    }): Promise<any>;
+    editArtifactMetadata(author: string, repository: string, category: string, subcategory: string, filename: string, data: {
+        updateDescription?: string;
+        updateNamespace?: string;
+        updateFilename?: string;
+        updateMimeType?: string;
+        updateTechnology?: string;
+        updateTags?: string;
+    }): Promise<any>;
+    /**
+     * List External Connections including SharePoint
+     * Returns markdown with a table of connections available
+     */
+    listExternalConnections(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<string>;
+    /**
+     * 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
+     */
+    accessConnection(connectionId: string, toolNames?: string[]): Promise<{
+        success: boolean;
+        connectionId: string;
+        connectionType: 'sharepoint' | 'remote-mcp';
+        connectionName: string;
+        isAuthenticated: boolean;
+        authRequired?: boolean;
+        loginUrl?: string;
+        loginMessage?: string;
+        error?: string;
+        tools?: any[];
+        markdown?: string;
+        instructions?: string;
+        policies?: string[];
+    }>;
+    /**
+     * 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
+     */
+    callRemoteTool(connectionId: string, toolName: string, args?: any): Promise<{
+        success: boolean;
+        connectionId: string;
+        connectionType: 'sharepoint' | 'remote-mcp';
+        toolName: string;
+        content?: Array<{
+            type: string;
+            text?: string;
+            data?: string;
+            mimeType?: string;
+            uri?: string;
+        }>;
+        error?: string;
+        errorCode?: string;
+        authRequired?: boolean;
+        loginUrl?: string;
+        loginMessage?: string;
+        tools?: Array<{
+            name: string;
+            description: string;
+            parameters: any;
+        }>;
+        markdown: string;
+    }>;
+    /**
+     * Search SharePoint documents using Microsoft Search API
+     * Uses V1 API - organizationId is auto-detected from auth token
+     */
+    sharePointSearch(connectionId: string, params: {
+        query: string;
+        limit?: number;
+        offset?: number;
+        fileType?: string;
+    }): Promise<any>;
+    /**
+     * List folders and files in SharePoint with pagination
+     * Uses V1 API - organizationId is auto-detected from auth token
+     */
+    sharePointListFolders(connectionId: string, params: {
+        folderPath?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<any>;
+    /**
+     * Read SharePoint file content with support for both fileUrl and legacy fileId
+     * Uses V1 API - organizationId is auto-detected from auth token
+     */
+    sharePointReadFile(connectionId: string, params: {
+        fileUrl: string;
+        extractMetadata?: boolean;
+        offset?: number;
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * 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)
+     */
+    sharePointReadRelatedFile(uri: string): Promise<any>;
+    /**
+     * Extract fileName from SharePoint related file URI
+     * Helper method for metadata purposes
+     */
+    private extractFileNameFromUri;
+    /**
+     * 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
+     */
+    sharePointSignOut(connectionId: string): Promise<any>;
+    /**
+     * 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
+     */
+    signOut(connectionType: string, connectionId: string): Promise<any>;
+    /**
+     * List all user's active OAuth authorizations
+     * @param connectionType - Optional filter: 'sharepoint' | 'remote-mcp' | 'all' (default: 'all')
+     */
+    listAuthorizations(connectionType?: string): Promise<any>;
+    /**
+     * List memory graphs, optionally filtered by scope
+     * @param scope - 'organization' | 'personal' | 'all' (default: 'all')
+     */
+    listMemoryGraphs(scope?: string): Promise<any>;
+    /**
+     * Create a new Memory Graph for the authenticated user
+     */
+    createMemoryGraph(data: {
+        label: string;
+        templateId: string;
+        description?: string;
+        scope?: string;
+    }): Promise<any>;
+    /**
+     * List available vocabulary templates for Memory Graph creation
+     */
+    listMemoryGraphTemplates(): Promise<any>;
+    /**
+     * Semantic vector search across multiple Memory Graphs
+     */
+    graphSearchMultiple(query: string, options?: {
+        graphIds?: string[];
+        entityTypes?: string[];
+        limit?: number;
+        similarityThreshold?: number;
+    }): Promise<any>;
+    /**
+     * List knowledge sets for an organization
+     */
+    listKnowledgeSets(): Promise<any>;
+    /**
+     * List knowledge set summary (markdown) for an organization
+     */
+    listKnowledgeSetSummary(): Promise<string>;
+    /**
+     * Open a knowledge set — returns markdown summary with contents and tool guidance
+     */
+    openKnowledgeSet(knowledgeSetId: string): Promise<string>;
+    /**
+     * Open a memory graph — returns vocabulary, stats, instructions, policies, and metadata
+     */
+    graphOpen(graphId: string): Promise<any>;
+    /**
+     * Find entities with filters and pagination
+     */
+    graphFindEntities(graphId: string, query: {
+        entityTypes?: string[];
+        searchTerm?: string;
+        detailLevel?: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Get a single entity by ID
+     */
+    graphGetEntity(graphId: string, entityId: string, detailLevel?: string): Promise<any>;
+    /**
+     * Get relationships for an entity
+     */
+    graphGetRelationships(graphId: string, entityId: string, options?: {
+        direction?: string;
+        relationshipTypes?: string[];
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Explore neighbourhood around an entity (BFS, 1-3 hops)
+     */
+    graphExplore(graphId: string, options: {
+        entityId: string;
+        maxDepth?: number;
+        relationshipTypes?: string[];
+        entityTypes?: string[];
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Find paths between two entities
+     */
+    graphFindPaths(graphId: string, options: {
+        sourceEntityId: string;
+        targetEntityId: string;
+        maxDepth?: number;
+        relationshipTypes?: string[];
+    }): Promise<any>;
+    /**
+     * Structured graph traversal with a JSON spec
+     */
+    graphTraverse(graphId: string, spec: {
+        start: Record<string, any>;
+        steps: Array<Record<string, any>>;
+        returnMode?: string;
+        limit?: number;
+        detailLevel?: string;
+    }): Promise<any>;
+    /**
+     * Semantic vector search on entity embeddings
+     */
+    graphSearch(graphId: string, query: string, options?: {
+        entityTypes?: string[];
+        limit?: number;
+        similarityThreshold?: number;
+    }): Promise<any>;
+    /**
+     * Create one or more entities
+     */
+    graphCreateEntities(graphId: string, entities: Array<{
+        entityType: string;
+        label: string;
+        summary?: string;
+        properties?: Record<string, unknown>;
+        data?: unknown;
+    }>): Promise<any>;
+    /**
+     * Update one or more entities
+     */
+    graphUpdateEntities(graphId: string, updates: Array<{
+        entityId: string;
+        label?: string;
+        summary?: string;
+        properties?: Record<string, unknown>;
+        data?: unknown;
+    }>): Promise<any>;
+    /**
+     * Delete one or more entities
+     */
+    graphDeleteEntities(graphId: string, entityIds: string[]): Promise<any>;
+    /**
+     * Create one or more relationships
+     */
+    graphCreateRelationships(graphId: string, relationships: Array<{
+        sourceEntityId: string;
+        targetEntityId: string;
+        relationshipType: string;
+        properties?: Record<string, unknown>;
+    }>): Promise<any>;
+    /**
+     * Delete one or more relationships
+     */
+    graphDeleteRelationships(graphId: string, relationshipIds: string[]): Promise<any>;
+    /**
+     * Delete an entire memory graph (SQL record + CosmosDB repository)
+     */
+    graphDelete(graphId: string): Promise<any>;
+    /**
+     * Propose vocabulary extensions (entity types / relationship types)
+     */
+    graphProposeVocabulary(graphId: string, proposals: {
+        entityTypes?: Array<{
+            type: string;
+            description: string;
+            justification: string;
+            properties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+        }>;
+        relationshipTypes?: Array<{
+            type: string;
+            description: string;
+            justification: string;
+            allowedSourceTypes: string[];
+            allowedTargetTypes: string[];
+            bidirectional?: boolean;
+            properties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+        }>;
+    }): Promise<any>;
+}
+//# sourceMappingURL=UcmLocalApiClient.d.ts.map