snow-flow 4.6.9 → 5.0.1

package/dist/mcp/servicenow-mcp-unified/index.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * ServiceNow Unified MCP Server Entry Point
+ *
+ * Consolidates 34 separate ServiceNow MCP servers into a single
+ * unified server with auto-discovery of 235+ tools.
+ *
+ * Usage:
+ *   node dist/mcp/servicenow-mcp-unified/index.js
+ *
+ * Environment Variables:
+ *   SERVICENOW_INSTANCE_URL - ServiceNow instance URL
+ *   SERVICENOW_CLIENT_ID - OAuth client ID
+ *   SERVICENOW_CLIENT_SECRET - OAuth client secret
+ *   SERVICENOW_REFRESH_TOKEN - OAuth refresh token (optional, will be cached)
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/servicenow-mcp-unified/index.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ServiceNow Unified MCP Server Entry Point
+ *
+ * Consolidates 34 separate ServiceNow MCP servers into a single
+ * unified server with auto-discovery of 235+ tools.
+ *
+ * Usage:
+ *   node dist/mcp/servicenow-mcp-unified/index.js
+ *
+ * Environment Variables:
+ *   SERVICENOW_INSTANCE_URL - ServiceNow instance URL
+ *   SERVICENOW_CLIENT_ID - OAuth client ID
+ *   SERVICENOW_CLIENT_SECRET - OAuth client secret
+ *   SERVICENOW_REFRESH_TOKEN - OAuth refresh token (optional, will be cached)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_js_1 = require("./server.js");
+/**
+ * Main entry point
+ */
+async function main() {
+    try {
+        // Create server instance
+        const server = new server_js_1.ServiceNowUnifiedServer();
+        // Initialize (discover tools, validate auth)
+        await server.initialize();
+        // Start server with stdio transport
+        await server.start();
+        // Graceful shutdown handlers
+        process.on('SIGINT', async () => {
+            console.log('\n[Main] Received SIGINT, shutting down gracefully...');
+            await server.stop();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            console.log('\n[Main] Received SIGTERM, shutting down gracefully...');
+            await server.stop();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        console.error('[Main] Fatal error:', error.message);
+        console.error(error.stack);
+        process.exit(1);
+    }
+}
+// Run server
+main();
+//# sourceMappingURL=index.js.map

package/dist/mcp/servicenow-mcp-unified/scripts/validate-tools.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env ts-node
+/**
+ * Tool Registry Validation Script
+ *
+ * Validates that all 235+ tools can be discovered and registered correctly.
+ */
+export {};
+//# sourceMappingURL=validate-tools.d.ts.map

package/dist/mcp/servicenow-mcp-unified/scripts/validate-tools.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env ts-node
+"use strict";
+/**
+ * Tool Registry Validation Script
+ *
+ * Validates that all 235+ tools can be discovered and registered correctly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tool_registry_js_1 = require("../shared/tool-registry.js");
+async function main() {
+    console.log('='.repeat(80));
+    console.log('ServiceNow MCP Unified - Tool Registry Validation');
+    console.log('='.repeat(80));
+    console.log('');
+    try {
+        // Initialize the tool registry with auto-discovery
+        console.log('🔍 Starting tool discovery...');
+        const discoveryResult = await tool_registry_js_1.toolRegistry.initialize();
+        console.log('');
+        console.log('📊 Discovery Results:');
+        console.log('─'.repeat(80));
+        console.log(`  Total Domains Found:     ${discoveryResult.domains.length}`);
+        console.log(`  Tools Discovered:        ${discoveryResult.toolsFound}`);
+        console.log(`  Tools Registered:        ${discoveryResult.toolsRegistered}`);
+        console.log(`  Registration Failures:   ${discoveryResult.toolsFailed}`);
+        console.log(`  Discovery Duration:      ${discoveryResult.duration}ms`);
+        console.log('');
+        // Get registry statistics
+        const stats = tool_registry_js_1.toolRegistry.getStatistics();
+        console.log('📈 Registry Statistics:');
+        console.log('─'.repeat(80));
+        console.log(`  Total Tools:             ${stats.totalTools}`);
+        console.log(`  Total Domains:           ${stats.totalDomains}`);
+        console.log('');
+        // Display tools by domain
+        console.log('📦 Tools by Domain:');
+        console.log('─'.repeat(80));
+        const sortedDomains = Object.entries(stats.toolsByDomain)
+            .sort(([, a], [, b]) => b - a);
+        for (const [domain, count] of sortedDomains) {
+            console.log(`  ${domain.padEnd(30)} ${count.toString().padStart(3)} tools`);
+        }
+        console.log('');
+        // Check for errors
+        if (discoveryResult.errors.length > 0) {
+            console.log('❌ Registration Errors:');
+            console.log('─'.repeat(80));
+            for (const error of discoveryResult.errors) {
+                console.log(`  ${error.filePath}`);
+                console.log(`     Error: ${error.error}`);
+            }
+            console.log('');
+        }
+        // Validation summary
+        console.log('✅ Validation Summary:');
+        console.log('─'.repeat(80));
+        const expectedToolCount = 225;
+        const actualToolCount = stats.totalTools;
+        const toolCountMatch = actualToolCount === expectedToolCount;
+        console.log(`  Expected Tools:          ${expectedToolCount}`);
+        console.log(`  Actual Tools:            ${actualToolCount}`);
+        console.log(`  Count Match:             ${toolCountMatch ? '✅ YES' : '❌ NO'}`);
+        console.log('');
+        if (discoveryResult.toolsFailed > 0) {
+            console.log('⚠️  Some tools failed to register. Please review errors above.');
+            process.exit(1);
+        }
+        if (!toolCountMatch) {
+            console.log('⚠️  Tool count mismatch. Expected 235 tools.');
+            process.exit(1);
+        }
+        console.log('🎉 All tools successfully validated!');
+        console.log('');
+        console.log('='.repeat(80));
+    }
+    catch (error) {
+        console.error('');
+        console.error('❌ Validation Failed:');
+        console.error('─'.repeat(80));
+        console.error(`  ${error.message}`);
+        console.error('');
+        process.exit(1);
+    }
+}
+main().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=validate-tools.js.map

package/dist/mcp/servicenow-mcp-unified/server.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Unified ServiceNow MCP Server
+ *
+ * Consolidates 34 separate MCP servers into a single server with:
+ * - Auto-discovery of 235+ tools
+ * - Shared OAuth authentication
+ * - Unified error handling
+ * - Dynamic tool registration
+ *
+ * This eliminates ~15,000 LOC of duplicate code.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+/**
+ * ServiceNow Unified MCP Server
+ */
+export declare class ServiceNowUnifiedServer {
+    private server;
+    private context;
+    constructor();
+    /**
+     * Load ServiceNow context from environment variables
+     */
+    private loadContext;
+    /**
+     * Setup MCP request handlers
+     */
+    private setupHandlers;
+    /**
+     * Determine if operation should be retried automatically
+     */
+    private isRetryableOperation;
+    /**
+     * Initialize server (discover tools, validate, start)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Start server with stdio transport
+     */
+    start(): Promise<void>;
+    /**
+     * Stop server gracefully
+     */
+    stop(): Promise<void>;
+    /**
+     * Get server instance (for testing)
+     */
+    getServer(): Server;
+    /**
+     * Get auth manager (for testing)
+     */
+    getAuthManager(): import("./shared/auth.js").ServiceNowAuthManager;
+    /**
+     * Get tool registry (for testing)
+     */
+    getToolRegistry(): import("./shared/tool-registry.js").ToolRegistry;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/servicenow-mcp-unified/server.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Unified ServiceNow MCP Server
+ *
+ * Consolidates 34 separate MCP servers into a single server with:
+ * - Auto-discovery of 235+ tools
+ * - Shared OAuth authentication
+ * - Unified error handling
+ * - Dynamic tool registration
+ *
+ * This eliminates ~15,000 LOC of duplicate code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceNowUnifiedServer = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const tool_registry_js_1 = require("./shared/tool-registry.js");
+const auth_js_1 = require("./shared/auth.js");
+const error_handler_js_1 = require("./shared/error-handler.js");
+/**
+ * ServiceNow Unified MCP Server
+ */
+class ServiceNowUnifiedServer {
+    constructor() {
+        // Initialize MCP server
+        this.server = new index_js_1.Server({
+            name: 'servicenow-unified',
+            version: '1.0.0'
+        }, {
+            capabilities: {
+                tools: {}
+            }
+        });
+        // Load ServiceNow context from environment
+        this.context = this.loadContext();
+        // Setup request handlers
+        this.setupHandlers();
+    }
+    /**
+     * Load ServiceNow context from environment variables
+     */
+    loadContext() {
+        const instanceUrl = process.env.SERVICENOW_INSTANCE_URL;
+        const clientId = process.env.SERVICENOW_CLIENT_ID;
+        const clientSecret = process.env.SERVICENOW_CLIENT_SECRET;
+        const refreshToken = process.env.SERVICENOW_REFRESH_TOKEN;
+        if (!instanceUrl || !clientId || !clientSecret) {
+            throw new Error('Missing required environment variables: SERVICENOW_INSTANCE_URL, SERVICENOW_CLIENT_ID, SERVICENOW_CLIENT_SECRET');
+        }
+        return {
+            instanceUrl,
+            clientId,
+            clientSecret,
+            refreshToken
+        };
+    }
+    /**
+     * Setup MCP request handlers
+     */
+    setupHandlers() {
+        // List available tools
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+            const tools = tool_registry_js_1.toolRegistry.getToolDefinitions();
+            console.log(`[Server] Listing ${tools.length} tools`);
+            return {
+                tools: tools.map(tool => ({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema
+                }))
+            };
+        });
+        // Execute tool
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            console.log(`[Server] Executing tool: ${name}`);
+            try {
+                // Get tool from registry
+                const tool = tool_registry_js_1.toolRegistry.getTool(name);
+                if (!tool) {
+                    throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Tool not found: ${name}`);
+                }
+                // Execute tool with error handling
+                const result = await (0, error_handler_js_1.executeWithErrorHandling)(name, async () => {
+                    return await tool.executor(args, this.context);
+                }, {
+                    retry: this.isRetryableOperation(name),
+                    context: {
+                        args,
+                        instanceUrl: this.context.instanceUrl
+                    }
+                });
+                // Return result in MCP format
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2)
+                        }
+                    ]
+                };
+            }
+            catch (error) {
+                console.error(`[Server] Tool execution failed: ${name}`, error.message);
+                if (error instanceof error_handler_js_1.SnowFlowError) {
+                    throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, error.message, error.toToolResult());
+                }
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, error.message || 'Unknown error');
+            }
+        });
+        // Error handler
+        this.server.onerror = (error) => {
+            console.error('[Server] MCP Error:', error);
+        };
+    }
+    /**
+     * Determine if operation should be retried automatically
+     */
+    isRetryableOperation(toolName) {
+        // Operations that benefit from automatic retry
+        const retryableOperations = [
+            'snow_query_table',
+            'snow_discover_table_fields',
+            'snow_get_by_sysid',
+            'snow_comprehensive_search',
+            'snow_analyze_query'
+        ];
+        return retryableOperations.includes(toolName);
+    }
+    /**
+     * Initialize server (discover tools, validate, start)
+     */
+    async initialize() {
+        console.log('[Server] ServiceNow Unified MCP Server starting...');
+        console.log('[Server] Instance:', this.context.instanceUrl);
+        try {
+            // Initialize tool registry with auto-discovery
+            console.log('[Server] Discovering tools...');
+            const discoveryResult = await tool_registry_js_1.toolRegistry.initialize();
+            console.log('[Server] Tool discovery complete:');
+            console.log(`  - Domains: ${discoveryResult.domains.length}`);
+            console.log(`  - Tools found: ${discoveryResult.toolsFound}`);
+            console.log(`  - Tools registered: ${discoveryResult.toolsRegistered}`);
+            console.log(`  - Tools failed: ${discoveryResult.toolsFailed}`);
+            console.log(`  - Duration: ${discoveryResult.duration}ms`);
+            if (discoveryResult.toolsFailed > 0) {
+                console.warn('[Server] Some tools failed to load:');
+                discoveryResult.errors.forEach(err => {
+                    console.warn(`  - ${err.filePath}: ${err.error}`);
+                });
+            }
+            // Test authentication
+            console.log('[Server] Testing authentication...');
+            try {
+                await auth_js_1.authManager.getAuthenticatedClient(this.context);
+                console.log('[Server] Authentication successful');
+            }
+            catch (error) {
+                console.warn('[Server] Authentication test failed:', error.message);
+                console.warn('[Server] Server will start, but tool calls may fail until credentials are valid');
+            }
+            // Get server statistics
+            const stats = tool_registry_js_1.toolRegistry.getStatistics();
+            console.log('[Server] Server statistics:');
+            console.log(`  - Total tools: ${stats.totalTools}`);
+            console.log(`  - Total domains: ${stats.totalDomains}`);
+            console.log('  - Tools by domain:');
+            Object.entries(stats.toolsByDomain).forEach(([domain, count]) => {
+                console.log(`    - ${domain}: ${count} tools`);
+            });
+            console.log('[Server] Initialization complete ✅');
+        }
+        catch (error) {
+            console.error('[Server] Initialization failed:', error.message);
+            throw error;
+        }
+    }
+    /**
+     * Start server with stdio transport
+     */
+    async start() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        console.log('[Server] Connected via stdio transport');
+    }
+    /**
+     * Stop server gracefully
+     */
+    async stop() {
+        console.log('[Server] Stopping server...');
+        await this.server.close();
+        auth_js_1.authManager.clearCache();
+        console.log('[Server] Server stopped');
+    }
+    /**
+     * Get server instance (for testing)
+     */
+    getServer() {
+        return this.server;
+    }
+    /**
+     * Get auth manager (for testing)
+     */
+    getAuthManager() {
+        return auth_js_1.authManager;
+    }
+    /**
+     * Get tool registry (for testing)
+     */
+    getToolRegistry() {
+        return tool_registry_js_1.toolRegistry;
+    }
+}
+exports.ServiceNowUnifiedServer = ServiceNowUnifiedServer;
+//# sourceMappingURL=server.js.map

package/dist/mcp/servicenow-mcp-unified/shared/auth.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Shared OAuth 2.0 Authentication Module
+ *
+ * Provides a single OAuth implementation for all ServiceNow MCP tools.
+ * Replaces 34 duplicate auth implementations with unified token management.
+ *
+ * Features:
+ * - OAuth 2.0 refresh token flow
+ * - Automatic token refresh on expiry
+ * - Session persistence
+ * - Multi-instance support
+ * - Connection pooling
+ */
+import { AxiosInstance } from 'axios';
+import { ServiceNowContext } from './types';
+export interface ExtendedAxiosInstance extends AxiosInstance {
+    getRecord(table: string, sys_id: string): Promise<any>;
+    query(table: string, params?: any): Promise<any>;
+    updateRecord(table: string, sys_id: string, data: any): Promise<any>;
+}
+/**
+ * ServiceNow OAuth Manager
+ */
+export declare class ServiceNowAuthManager {
+    private tokenCache;
+    private clients;
+    private tokenRefreshPromises;
+    constructor();
+    /**
+     * Get authenticated Axios client for ServiceNow instance
+     */
+    getAuthenticatedClient(context: ServiceNowContext): Promise<ExtendedAxiosInstance>;
+    /**
+     * Get valid access token (from cache or refresh)
+     */
+    getAccessToken(context: ServiceNowContext): Promise<string>;
+    /**
+     * Refresh access token using refresh token
+     */
+    private refreshAccessToken;
+    /**
+     * Check if cached token is still valid
+     */
+    private isTokenValid;
+    /**
+     * Invalidate cached token for instance
+     */
+    private invalidateToken;
+    /**
+     * Get cache key for instance URL
+     */
+    private getCacheKey;
+    /**
+     * Load token cache from disk
+     */
+    private loadTokenCache;
+    /**
+     * Save token cache to disk
+     */
+    private saveTokenCache;
+    /**
+     * Get token cache file path
+     */
+    private getTokenCachePath;
+    /**
+     * Clear all cached tokens
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        cachedInstances: number;
+        activeClients: number;
+        tokens: Array<{
+            instanceUrl: string;
+            expiresIn: number;
+            valid: boolean;
+        }>;
+    };
+}
+/**
+ * Singleton instance for global use
+ */
+export declare const authManager: ServiceNowAuthManager;
+/**
+ * Convenience function to get authenticated client
+ */
+export declare function getAuthenticatedClient(context: ServiceNowContext): Promise<ExtendedAxiosInstance>;
+/**
+ * Convenience function to get access token
+ */
+export declare function getAccessToken(context: ServiceNowContext): Promise<string>;
+//# sourceMappingURL=auth.d.ts.map