@utaba/ucm-mcp-server 6.5.0 → 6.6.0

package/dist/mcp-server/server/ToolRegistry.js

@@ -0,0 +1,169 @@
+import { McpError, McpErrorCode } from '../utils/McpErrorHandler.js';
+// Import utility tools
+import { QuickstartTool } from '../tools/utility/QuickstartTool.js';
+import { AuthorIndexTool } from '../tools/utility/AuthorIndexTool.js';
+import { AuthorRecentsTool } from '../tools/utility/AuthorRecentsTool.js';
+import { ListRepositoriesTool } from '../tools/utility/ListRepositoriesTool.js';
+// Import core tools
+import { GetArtifactTool } from '../tools/core/GetArtifactTool.js';
+import { GetChunkTool } from '../tools/core/GetChunkTool.js';
+import { PublishArtifactTool } from '../tools/core/PublishArtifactTool.js';
+import { PublishArtifactFromFileTool } from '../tools/core/PublishArtifactFromFileTool.js';
+import { ListArtifactsTool } from '../tools/core/ListArtifactsTool.js';
+import { DeleteArtifactTool } from '../tools/core/DeleteArtifactTool.js';
+import { GetArtifactVersionsTool } from '../tools/core/GetArtifactVersionsTool.js';
+import { SearchArtifactsTool } from '../tools/core/SearchArtifactsTool.js';
+import { EditArtifactMetadataTool } from '../tools/core/EditArtifactMetadataTool.js';
+import { MoveArtifactTool } from '../tools/core/MoveArtifactTool.js';
+// Import repository tools
+import { CreateRepositoryTool } from '../tools/repository/CreateRepositoryTool.js';
+import { GetRepositoryTool } from '../tools/repository/GetRepositoryTool.js';
+import { UpdateRepositoryTool } from '../tools/repository/UpdateRepositoryTool.js';
+// Import connection/SharePoint tools
+import { ListConnectionsTool } from '../tools/sharepoint/SharePointListConnectionsTool.js';
+// DEPRECATED: Legacy SharePoint tools - use ucm_connection_call_tool via unified gateway instead
+// Commented out 2026-02-13 - pending confirmation that unified gateway works correctly
+// 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 unified authorization tools
+import { SignOutTool } from '../tools/authorization/SignOutTool.js';
+import { ListAuthorizationsTool } from '../tools/authorization/ListAuthorizationsTool.js';
+// Import connection tools
+import { AccessConnectionTool } from '../tools/connections/AccessConnectionTool.js';
+import { CallRemoteToolTool } from '../tools/connections/CallRemoteToolTool.js';
+// Import memory graph tools
+import { GraphListTool } from '../tools/memory-graph/GraphListTool.js';
+import { GraphCreateTool } from '../tools/memory-graph/GraphCreateTool.js';
+import { GraphListTemplatesTool } from '../tools/memory-graph/GraphListTemplatesTool.js';
+import { KnowledgeSetListTool } from '../tools/memory-graph/KnowledgeSetListTool.js';
+import { KnowledgeSetOpenTool } from '../tools/memory-graph/KnowledgeSetOpenTool.js';
+import { GraphOpenTool } from '../tools/memory-graph/GraphOpenTool.js';
+import { GraphFindEntitiesTool } from '../tools/memory-graph/GraphFindEntitiesTool.js';
+import { GraphGetEntityTool } from '../tools/memory-graph/GraphGetEntityTool.js';
+import { GraphGetRelationshipsTool } from '../tools/memory-graph/GraphGetRelationshipsTool.js';
+import { GraphExploreTool } from '../tools/memory-graph/GraphExploreTool.js';
+import { GraphFindPathsTool } from '../tools/memory-graph/GraphFindPathsTool.js';
+import { GraphTraverseTool } from '../tools/memory-graph/GraphTraverseTool.js';
+import { GraphSearchTool } from '../tools/memory-graph/GraphSearchTool.js';
+import { GraphCreateEntitiesTool } from '../tools/memory-graph/GraphCreateEntitiesTool.js';
+import { GraphUpdateEntitiesTool } from '../tools/memory-graph/GraphUpdateEntitiesTool.js';
+import { GraphDeleteEntitiesTool } from '../tools/memory-graph/GraphDeleteEntitiesTool.js';
+import { GraphCreateRelationshipsTool } from '../tools/memory-graph/GraphCreateRelationshipsTool.js';
+import { GraphDeleteRelationshipsTool } from '../tools/memory-graph/GraphDeleteRelationshipsTool.js';
+import { GraphProposeVocabularyTool } from '../tools/memory-graph/GraphProposeVocabularyTool.js';
+export class ToolRegistry {
+    ucmClient;
+    logger;
+    trustedAuthors;
+    authorId;
+    baseUrl;
+    tools = new Map();
+    constructor(ucmClient, logger, trustedAuthors = [], authorId, baseUrl) {
+        this.ucmClient = ucmClient;
+        this.logger = logger;
+        this.trustedAuthors = trustedAuthors;
+        this.authorId = authorId;
+        this.baseUrl = baseUrl;
+        this.registerTools();
+    }
+    registerTools() {
+        // Register utility tools
+        this.registerTool(new QuickstartTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new AuthorIndexTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new AuthorRecentsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new ListRepositoriesTool(this.ucmClient, this.logger, this.authorId));
+        // Register core tools
+        this.registerTool(new GetArtifactTool(this.ucmClient, this.logger, this.authorId, this.trustedAuthors));
+        this.registerTool(new GetChunkTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new PublishArtifactFromFileTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new PublishArtifactTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new ListArtifactsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new DeleteArtifactTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GetArtifactVersionsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new SearchArtifactsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new EditArtifactMetadataTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new MoveArtifactTool(this.ucmClient, this.logger, this.authorId));
+        // Register repository tools
+        this.registerTool(new CreateRepositoryTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GetRepositoryTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new UpdateRepositoryTool(this.ucmClient, this.logger, this.authorId));
+        // Register connection tools (ListConnectionsTool is unified - lists all connection types)
+        this.registerTool(new ListConnectionsTool(this.ucmClient, this.logger, this.authorId));
+        // DEPRECATED: Legacy SharePoint tools - use ucm_connection_call_tool via unified gateway instead
+        // Commented out 2026-02-13 - pending confirmation that unified gateway works correctly
+        // 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));
+        // Register connection tools (unified gateway)
+        this.registerTool(new AccessConnectionTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new CallRemoteToolTool(this.ucmClient, this.logger, this.authorId));
+        // Register unified authorization tools
+        this.registerTool(new SignOutTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new ListAuthorizationsTool(this.ucmClient, this.logger, this.authorId));
+        // Register memory graph tools
+        this.registerTool(new GraphListTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphCreateTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphListTemplatesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new KnowledgeSetListTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new KnowledgeSetOpenTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphOpenTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphFindEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphGetEntityTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphGetRelationshipsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphExploreTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphFindPathsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphTraverseTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphSearchTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphCreateEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphUpdateEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphDeleteEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphCreateRelationshipsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphDeleteRelationshipsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphProposeVocabularyTool(this.ucmClient, this.logger, this.authorId));
+        this.logger.info('ToolRegistry', `Registered ${this.tools.size} MCP tools`);
+    }
+    registerTool(tool) {
+        if (this.tools.has(tool.name)) {
+            this.logger.warn('ToolRegistry', `Tool ${tool.name} already registered, overwriting`);
+        }
+        this.tools.set(tool.name, tool);
+        this.logger.debug('ToolRegistry', `Registered tool: ${tool.name}`);
+    }
+    async listTools() {
+        const toolList = [];
+        for (const [, tool] of this.tools) {
+            toolList.push({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema
+            });
+        }
+        return toolList;
+    }
+    async executeTool(name, params) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            throw new McpError(McpErrorCode.MethodNotFound, `Tool '${name}' not found`);
+        }
+        this.logger.debug('ToolRegistry', `Executing tool: ${name}`);
+        try {
+            const result = await tool.execute(params);
+            this.logger.debug('ToolRegistry', `Tool ${name} completed successfully`);
+            return result;
+        }
+        catch (error) {
+            this.logger.error('ToolRegistry', `Tool ${name} execution failed`, '', error);
+            throw error;
+        }
+    }
+    getToolCount() {
+        return this.tools.size;
+    }
+    hasToolnamed(name) {
+        return this.tools.has(name);
+    }
+}
+//# sourceMappingURL=ToolRegistry.js.map

package/dist/mcp-server/tools/authorization/ListAuthorizationsTool.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ListAuthorizationsTool - List all user's active OAuth authorizations
+ */
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class ListAuthorizationsTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected validateParams(params: any): void;
+    protected handleExecute(params: {
+        connectionType?: string;
+    }): Promise<any>;
+    /**
+     * Format authorizations response as markdown
+     */
+    private formatAuthorizationsResponse;
+}
+//# sourceMappingURL=ListAuthorizationsTool.d.ts.map

package/dist/mcp-server/tools/authorization/ListAuthorizationsTool.js

@@ -0,0 +1,146 @@
+/**
+ * ListAuthorizationsTool - List all user's active OAuth authorizations
+ */
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+export class ListAuthorizationsTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() {
+        return 'ucm_connection_list_auth';
+    }
+    get description() {
+        return 'List all your active OAuth authorizations across connection types. Shows which services you are currently authorized to access, with expiry info and connection details.';
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                connectionType: {
+                    type: 'string',
+                    enum: ['sharepoint', 'remote-mcp', 'all'],
+                    description: 'Filter by connection type. Default: "all"'
+                }
+            },
+            required: []
+        };
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        // Validate connectionType if provided
+        if (params.connectionType) {
+            const validTypes = ['sharepoint', 'remote-mcp', 'all'];
+            if (!validTypes.includes(params.connectionType)) {
+                throw new McpError(McpErrorCode.InvalidParams, `connectionType must be one of: ${validTypes.join(', ')}`);
+            }
+        }
+    }
+    async handleExecute(params) {
+        const filter = params.connectionType || 'all';
+        this.logger.info('ListAuthorizationsTool', `Listing authorizations (filter: ${filter})`);
+        try {
+            // Call API to list authorizations
+            const result = await this.ucmClient.listAuthorizations(filter);
+            this.logger.info('ListAuthorizationsTool', 'Authorizations retrieved successfully', '', {
+                filter,
+                count: result.authorizations?.length || 0
+            });
+            // Return structured markdown response
+            const markdown = this.formatAuthorizationsResponse(result, filter);
+            return markdown;
+        }
+        catch (error) {
+            const sanitizedError = {
+                message: error?.message,
+                status: error?.response?.status,
+                data: error?.response?.data
+            };
+            this.logger.error('ListAuthorizationsTool', 'Failed to list authorizations', '', sanitizedError);
+            if (error instanceof McpError) {
+                throw error;
+            }
+            if (error.response) {
+                const status = error.response.status;
+                const errorData = error.response.data;
+                if (status === 401 || status === 403) {
+                    throw new McpError(McpErrorCode.InvalidRequest, `Access denied: ${errorData?.message || 'Not authorized'}`);
+                }
+                throw new McpError(McpErrorCode.InternalError, `API error: ${errorData?.message || error.message}`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to list authorizations: ${error.message}`);
+        }
+    }
+    /**
+     * Format authorizations response as markdown
+     */
+    formatAuthorizationsResponse(result, filter) {
+        const lines = [];
+        const authorizations = result.authorizations || [];
+        lines.push('# Your OAuth Authorizations\n');
+        if (authorizations.length === 0) {
+            if (filter === 'all') {
+                lines.push('You have no active OAuth authorizations.\n');
+                lines.push('When you access services that require OAuth (like SharePoint or Remote MCP Servers), you will be prompted to authorize.');
+            }
+            else {
+                lines.push(`You have no active ${filter} authorizations.\n`);
+            }
+        }
+        else {
+            lines.push(`Found ${authorizations.length} active authorization(s)${filter !== 'all' ? ` for ${filter}` : ''}.\n`);
+            // Group by connection type
+            const grouped = new Map();
+            for (const auth of authorizations) {
+                const type = auth.connectionType || 'other';
+                if (!grouped.has(type)) {
+                    grouped.set(type, []);
+                }
+                grouped.get(type).push(auth);
+            }
+            const typeNames = {
+                'sharepoint': 'SharePoint Connections',
+                'remote-mcp': 'Remote MCP Servers'
+            };
+            for (const [type, auths] of grouped) {
+                const typeName = typeNames[type] || type;
+                lines.push(`## ${typeName}\n`);
+                for (const auth of auths) {
+                    const now = new Date();
+                    const refreshTokenExpiresAt = auth.refreshTokenExpiresAt ? new Date(auth.refreshTokenExpiresAt) : null;
+                    const accessTokenExpiresAt = auth.expiresAt ? new Date(auth.expiresAt) : null;
+                    // Authorization is expired only if refresh token has expired
+                    // Access token expiry doesn't matter - it will auto-refresh
+                    const isExpired = refreshTokenExpiresAt ? refreshTokenExpiresAt < now : false;
+                    const accessTokenExpired = accessTokenExpiresAt ? accessTokenExpiresAt < now : false;
+                    let status;
+                    if (isExpired) {
+                        status = '**Expired** (re-authorization required)';
+                    }
+                    else if (refreshTokenExpiresAt) {
+                        status = `Active (valid until ${refreshTokenExpiresAt.toISOString()} UTC)`;
+                    }
+                    else {
+                        // No refresh token expiry means it doesn't expire (e.g., Google)
+                        status = 'Active (does not expire)';
+                    }
+                    lines.push(`### ${auth.connectionName || auth.connectionId}`);
+                    lines.push(`- **Connection ID**: ${auth.connectionId}`);
+                    lines.push(`- **Provider**: ${auth.providerType || type}`);
+                    lines.push(`- **Status**: ${status}`);
+                    if (accessTokenExpired && !isExpired) {
+                        lines.push(`- **Note**: Access token expired but will auto-refresh on next use`);
+                    }
+                    if (auth.scopes) {
+                        lines.push(`- **Scopes**: ${auth.scopes}`);
+                    }
+                    lines.push('');
+                }
+            }
+            lines.push('\n## Actions\n');
+            lines.push('To revoke an authorization, use: `ucm_connection_signout` with connectionType and connectionId');
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=ListAuthorizationsTool.js.map

package/dist/mcp-server/tools/authorization/SignOutTool.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SignOutTool - Unified OAuth sign out for all connection types
+ * Replaces SharePointSignOutTool with a unified tool supporting multiple connection types
+ */
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class SignOutTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected validateParams(params: any): void;
+    protected handleExecute(params: {
+        connectionType: string;
+        connectionId: string;
+    }): Promise<any>;
+    /**
+     * Format sign out response as markdown
+     */
+    private formatSignOutResponse;
+}
+//# sourceMappingURL=SignOutTool.d.ts.map

package/dist/mcp-server/tools/authorization/SignOutTool.js

@@ -0,0 +1,128 @@
+/**
+ * SignOutTool - Unified OAuth sign out for all connection types
+ * Replaces SharePointSignOutTool with a unified tool supporting multiple connection types
+ */
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+export class SignOutTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() {
+        return 'ucm_connection_signout';
+    }
+    get description() {
+        return 'Sign out from an OAuth-authorized connection. Revokes user-delegated permissions by deleting access tokens. Works for SharePoint OnBehalfOf connections and Remote MCP Servers with user-delegated OAuth.';
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                connectionType: {
+                    type: 'string',
+                    enum: ['sharepoint', 'remote-mcp'],
+                    description: 'Type of connection: "sharepoint" or "remote-mcp"'
+                },
+                connectionId: {
+                    type: 'string',
+                    description: 'Connection ID to revoke authorization for (get from ucm_connection_list_auth or ucm_connection_list)',
+                    minLength: 36,
+                    maxLength: 36
+                }
+            },
+            required: ['connectionType', 'connectionId']
+        };
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        // Validate connectionType
+        if (!params.connectionType || typeof params.connectionType !== 'string') {
+            throw new McpError(McpErrorCode.InvalidParams, 'connectionType is required and must be a string');
+        }
+        const validTypes = ['sharepoint', 'remote-mcp'];
+        if (!validTypes.includes(params.connectionType)) {
+            throw new McpError(McpErrorCode.InvalidParams, `connectionType must be one of: ${validTypes.join(', ')}`);
+        }
+        // Validate connectionId
+        if (!params.connectionId || typeof params.connectionId !== 'string') {
+            throw new McpError(McpErrorCode.InvalidParams, 'connectionId is required and must be a string');
+        }
+        if (params.connectionId.length !== 36) {
+            throw new McpError(McpErrorCode.InvalidParams, 'connectionId must be a valid UUID (36 characters)');
+        }
+    }
+    async handleExecute(params) {
+        this.logger.info('SignOutTool', `Revoking ${params.connectionType} authorization for connection ${params.connectionId}`);
+        try {
+            // Call unified API method
+            const result = await this.ucmClient.signOut(params.connectionType, params.connectionId);
+            this.logger.info('SignOutTool', 'Authorization revoked successfully', '', {
+                connectionType: params.connectionType,
+                connectionId: params.connectionId,
+                success: result.success
+            });
+            // Return structured markdown response
+            const markdown = this.formatSignOutResponse(params.connectionType, params.connectionId, result);
+            return markdown;
+        }
+        catch (error) {
+            // Sanitize error for logging to avoid circular reference issues
+            const sanitizedError = {
+                message: error?.message,
+                status: error?.response?.status,
+                data: error?.response?.data
+            };
+            this.logger.error('SignOutTool', 'Failed to revoke authorization', '', sanitizedError);
+            if (error instanceof McpError) {
+                throw error;
+            }
+            // Handle API errors
+            if (error.response) {
+                const status = error.response.status;
+                const errorData = error.response.data;
+                if (status === 401 || status === 403) {
+                    throw new McpError(McpErrorCode.InvalidRequest, `Access denied: ${errorData?.message || 'Not authorized to revoke authorization'}`);
+                }
+                if (status === 404) {
+                    throw new McpError(McpErrorCode.InvalidRequest, `Connection not found: ${errorData?.message || 'Connection does not exist'}`);
+                }
+                if (status === 400 && errorData?.error === 'INVALID_AUTH_TYPE') {
+                    throw new McpError(McpErrorCode.InvalidRequest, `Invalid operation: This connection does not use user-delegated authentication.`);
+                }
+                throw new McpError(McpErrorCode.InternalError, `API error: ${errorData?.message || error.message}`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to revoke authorization: ${error.message}`);
+        }
+    }
+    /**
+     * Format sign out response as markdown
+     */
+    formatSignOutResponse(connectionType, connectionId, result) {
+        const lines = [];
+        const providerName = connectionType === 'sharepoint' ? 'SharePoint' : 'Remote MCP Server';
+        lines.push(`# ${providerName} Authorization Revoked\n`);
+        if (result.success) {
+            lines.push(`✅ **Status**: ${result.message || 'Authorization successfully revoked'}\n`);
+            lines.push(`**Connection ID**: ${result.connectionId || connectionId}\n`);
+            if (result.connectionName) {
+                lines.push(`**Connection Name**: ${result.connectionName}\n`);
+            }
+            if (result.revokedAt) {
+                lines.push(`**Revoked At**: ${new Date(result.revokedAt).toLocaleString()}\n`);
+            }
+            lines.push('\n## What This Means\n');
+            lines.push('- Your access tokens have been deleted from the system');
+            lines.push(`- You are now signed out of this ${providerName} connection`);
+            lines.push('- To access this service again, you will be prompted to re-authorize on next use\n');
+        }
+        else {
+            lines.push('⚠️ **Status**: Revocation failed or not needed\n');
+            lines.push(`**Message**: ${result.message}\n`);
+            if (result.details?.reason) {
+                lines.push(`**Reason**: ${result.details.reason}\n`);
+            }
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=SignOutTool.js.map

package/dist/mcp-server/tools/base/BaseToolController.d.ts

@@ -0,0 +1,19 @@
+import { IMcpTool } from '../../interfaces/IMcpTool.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { ZodSchema } from 'zod';
+export declare abstract class BaseToolController implements IMcpTool {
+    protected ucmClient: UcmLocalApiClient;
+    protected logger: ILogger;
+    protected publishingAuthorId?: string | undefined;
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string | undefined);
+    abstract get name(): string;
+    abstract get description(): string;
+    abstract get inputSchema(): Record<string, unknown>;
+    /** Override to provide a zod schema for runtime validation */
+    get schema(): ZodSchema | undefined;
+    execute(params: Record<string, unknown>): Promise<string>;
+    protected abstract handleExecute(params: Record<string, unknown>): Promise<string>;
+    protected validateParams(params: Record<string, unknown>): void;
+}
+//# sourceMappingURL=BaseToolController.d.ts.map

package/dist/mcp-server/tools/base/BaseToolController.js

@@ -0,0 +1,58 @@
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { ZodError } from 'zod';
+export class BaseToolController {
+    ucmClient;
+    logger;
+    publishingAuthorId;
+    constructor(ucmClient, logger, publishingAuthorId) {
+        this.ucmClient = ucmClient;
+        this.logger = logger;
+        this.publishingAuthorId = publishingAuthorId;
+    }
+    /** Override to provide a zod schema for runtime validation */
+    get schema() { return undefined; }
+    async execute(params) {
+        try {
+            let validated;
+            if (this.schema) {
+                validated = this.schema.parse(params);
+            }
+            else {
+                this.validateParams(params);
+                validated = params;
+            }
+            return await this.handleExecute(validated);
+        }
+        catch (error) {
+            if (error instanceof ZodError) {
+                throw new McpError(McpErrorCode.InvalidParams, `Invalid parameters: ${error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`);
+            }
+            // Sanitize error for logging to avoid circular reference issues with axios errors
+            const err = error;
+            const response = err?.response;
+            const config = err?.config;
+            const sanitizedError = {
+                message: err?.message,
+                name: err?.name,
+                status: response?.status,
+                statusText: response?.statusText,
+                data: response?.data,
+                url: config?.url
+            };
+            this.logger.error('BaseToolController', `Tool ${this.name} execution failed`, '', sanitizedError);
+            throw error;
+        }
+    }
+    validateParams(params) {
+        // Legacy validation for tools that haven't adopted zod schemas yet
+        const schema = this.inputSchema;
+        if (schema.required) {
+            for (const field of schema.required) {
+                if (params[field] === undefined || params[field] === null) {
+                    throw new McpError(McpErrorCode.InvalidParams, `Required parameter '${field}' is missing`);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=BaseToolController.js.map

package/dist/mcp-server/tools/connections/AccessConnectionTool.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AccessConnectionTool
+ * Access a specific external connection, check auth status, and return available tool schemas.
+ *
+ * Phase 2 of Unified Connection Gateway Implementation
+ */
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class AccessConnectionTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected validateParams(params: any): void;
+    protected handleExecute(params: {
+        connectionId: string;
+        toolNames?: string[];
+    }): Promise<any>;
+}
+//# sourceMappingURL=AccessConnectionTool.d.ts.map