snow-flow 2.6.4 → 2.6.6

package/dist/mcp/servicenow-update-set-mcp-refactored.js

@@ -1,662 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Update Set Management MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- * Ensures all changes are tracked in Update Sets for safe deployment
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowUpdateSetMCP = void 0;
-const base_mcp_server_js_1 = require("./base-mcp-server.js");
-const fs_1 = require("fs");
-const path_1 = require("path");
-class ServiceNowUpdateSetMCP extends base_mcp_server_js_1.BaseMCPServer {
-    setupTools() {
-        // Tools are set up via getTools() method
-    }
-    constructor() {
-        super({
-            name: 'servicenow-update-set',
-            version: '2.0.0',
-            description: 'Update Set management server with BaseMCPServer pattern'
-        });
-        this.currentSession = null;
-        this.sessionsPath = (0, path_1.join)(process.cwd(), 'memory', 'update-set-sessions');
-        this.ensureSessionsDirectory();
-        this.loadActiveSession();
-    }
-    getTools() {
-        return [
-            {
-                name: 'snow_update_set_create',
-                description: 'Create a new Update Set for a user story or feature - ALWAYS use this before making changes',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string', description: 'Update Set name (e.g., "STORY-123: Add incident widget")' },
-                        description: { type: 'string', description: 'Detailed description of changes' },
-                        user_story: { type: 'string', description: 'User story or ticket number' },
-                        release_date: { type: 'string', description: 'Target release date (optional)' },
-                        auto_switch: {
-                            type: 'boolean',
-                            default: true,
-                            description: 'Automatically switch to the created Update Set (default: true)'
-                        }
-                    },
-                    required: ['name', 'description']
-                }
-            },
-            {
-                name: 'snow_update_set_switch',
-                description: 'Switch to an existing Update Set - use this to continue work on a story',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        update_set_id: { type: 'string', description: 'Update Set sys_id to switch to' }
-                    },
-                    required: ['update_set_id']
-                }
-            },
-            {
-                name: 'snow_update_set_current',
-                description: 'Get the current active Update Set session',
-                inputSchema: {
-                    type: 'object',
-                    properties: {}
-                }
-            },
-            {
-                name: 'snow_update_set_list',
-                description: 'List all Update Sets (in progress and recent)',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        limit: { type: 'number', description: 'Maximum number of results (default: 10)' },
-                        state: {
-                            type: 'string',
-                            enum: ['in_progress', 'complete', 'released'],
-                            description: 'Filter by state'
-                        }
-                    }
-                }
-            },
-            {
-                name: 'snow_update_set_complete',
-                description: 'Mark Update Set as complete and ready for testing',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        update_set_id: { type: 'string', description: 'Update Set sys_id to complete (uses current if not specified)' },
-                        notes: { type: 'string', description: 'Completion notes or testing instructions' }
-                    }
-                }
-            },
-            {
-                name: 'snow_update_set_add_artifact',
-                description: 'Track an artifact in the current Update Set session',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        type: { type: 'string', description: 'Artifact type (widget, flow, script, etc.)' },
-                        sys_id: { type: 'string', description: 'ServiceNow sys_id of the artifact' },
-                        name: { type: 'string', description: 'Artifact name for tracking' }
-                    },
-                    required: ['type', 'sys_id', 'name']
-                }
-            },
-            {
-                name: 'snow_ensure_active_update_set',
-                description: 'Ensure there is an active Update Set session - creates one automatically if needed',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        context: { type: 'string', description: 'Context for auto-created Update Set (e.g., "widget development", "flow creation")' },
-                        auto_create: {
-                            type: 'boolean',
-                            default: true,
-                            description: 'Automatically create Update Set if none exists (default: true)'
-                        }
-                    }
-                }
-            },
-            {
-                name: 'snow_update_set_preview',
-                description: 'Preview all changes in an Update Set',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        update_set_id: { type: 'string', description: 'Update Set sys_id (uses current if not specified)' }
-                    }
-                }
-            },
-            {
-                name: 'snow_update_set_export',
-                description: 'Export Update Set as XML for backup or migration',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        update_set_id: { type: 'string', description: 'Update Set sys_id to export' },
-                        output_path: { type: 'string', description: 'Path to save the XML file' }
-                    }
-                }
-            }
-        ];
-    }
-    async executeTool(name, args) {
-        switch (name) {
-            case 'snow_update_set_create':
-                return this.createUpdateSet(args);
-            case 'snow_update_set_switch':
-                return this.switchUpdateSet(args);
-            case 'snow_update_set_current':
-                return this.getCurrentUpdateSet();
-            case 'snow_update_set_list':
-                return this.listUpdateSets(args);
-            case 'snow_update_set_complete':
-                return this.completeUpdateSet(args);
-            case 'snow_update_set_add_artifact':
-                return this.addArtifactToSession(args);
-            case 'snow_ensure_active_update_set':
-                return this.ensureActiveUpdateSet(args);
-            case 'snow_update_set_preview':
-                return this.previewUpdateSet(args);
-            case 'snow_update_set_export':
-                return this.exportUpdateSet(args);
-            default:
-                return {
-                    success: false,
-                    error: `Unknown tool: ${name}`
-                };
-        }
-    }
-    async createUpdateSet(args) {
-        const startTime = Date.now();
-        try {
-            const { name, description, user_story, release_date, auto_switch = true } = args;
-            // Create Update Set in ServiceNow
-            const updateSetData = {
-                name,
-                description,
-                user_story,
-                release_date: release_date || '',
-                state: 'in_progress',
-                application: 'global'
-            };
-            const response = await this.client.makeRequest({
-                method: 'POST',
-                url: '/api/now/table/sys_update_set',
-                data: updateSetData
-            });
-            // Validate response structure
-            if (!response || !response.result) {
-                throw new Error(`Invalid API response: ${JSON.stringify(response)}`);
-            }
-            const updateSet = response.result;
-            // Create session
-            const session = {
-                update_set_id: updateSet.sys_id,
-                name: updateSet.name,
-                description: updateSet.description,
-                user_story: updateSet.user_story,
-                created_at: new Date().toISOString(),
-                state: 'in_progress',
-                artifacts: [],
-                auto_switched: auto_switch,
-                active_session: auto_switch
-            };
-            // Save session
-            await this.saveSession(session);
-            // Switch to new Update Set if requested
-            if (auto_switch) {
-                await this.switchToUpdateSet(updateSet.sys_id);
-                this.currentSession = session;
-            }
-            this.logger.info(`Created Update Set: ${name} (${updateSet.sys_id})`);
-            return {
-                success: true,
-                result: {
-                    update_set_id: updateSet.sys_id,
-                    name: updateSet.name,
-                    switched: auto_switch,
-                    session_created: true
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Update Set', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to create Update Set',
-                retryable: false, // Simplified error handling
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async switchUpdateSet(args) {
-        const startTime = Date.now();
-        try {
-            const { update_set_id } = args;
-            // Switch in ServiceNow
-            await this.switchToUpdateSet(update_set_id);
-            // Load or create session for this Update Set
-            let session = await this.loadSessionById(update_set_id);
-            if (!session) {
-                // Fetch Update Set details from ServiceNow
-                const response = await this.client.makeRequest({
-                    method: 'GET',
-                    url: `/api/now/table/sys_update_set/${update_set_id}`
-                });
-                const updateSet = response.result;
-                // Create new session
-                session = {
-                    update_set_id: updateSet.sys_id,
-                    name: updateSet.name,
-                    description: updateSet.description,
-                    user_story: updateSet.user_story,
-                    created_at: updateSet.sys_created_on,
-                    state: updateSet.state,
-                    artifacts: [],
-                    active_session: true
-                };
-                await this.saveSession(session);
-            }
-            // Mark as current session
-            this.currentSession = session;
-            this.currentSession.active_session = true;
-            await this.saveSession(this.currentSession);
-            return {
-                success: true,
-                result: {
-                    update_set_id: session.update_set_id,
-                    name: session.name,
-                    artifacts_count: session.artifacts.length
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to switch Update Set', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to switch Update Set',
-                retryable: false, // Simplified error handling
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async getCurrentUpdateSet() {
-        const startTime = Date.now();
-        try {
-            if (!this.currentSession) {
-                // Try to get from ServiceNow
-                const response = await this.client.makeRequest({
-                    method: 'GET',
-                    url: '/api/now/table/sys_update_set',
-                    params: {
-                        sysparm_query: 'state=in_progress^sys_created_byDYNAMIC90d1921e5f510100a9ad2572f2b477fe',
-                        sysparm_limit: 1,
-                        sysparm_fields: 'sys_id,name,description,state'
-                    }
-                });
-                if (response.result && response.result.length > 0) {
-                    const updateSet = response.result[0];
-                    return {
-                        success: true,
-                        result: {
-                            update_set_id: updateSet.sys_id,
-                            name: updateSet.name,
-                            description: updateSet.description,
-                            state: updateSet.state,
-                            session_active: false
-                        },
-                        executionTime: Date.now() - startTime
-                    };
-                }
-                return {
-                    success: true,
-                    result: {
-                        message: 'No active Update Set session found',
-                        recommendation: 'Use snow_update_set_create to create a new Update Set'
-                    },
-                    executionTime: Date.now() - startTime
-                };
-            }
-            return {
-                success: true,
-                result: {
-                    update_set_id: this.currentSession.update_set_id,
-                    name: this.currentSession.name,
-                    description: this.currentSession.description,
-                    state: this.currentSession.state,
-                    artifacts_count: this.currentSession.artifacts.length,
-                    artifacts: this.currentSession.artifacts,
-                    session_active: true
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to get current Update Set', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to get current Update Set',
-                retryable: false, // Simplified error handling
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async listUpdateSets(args) {
-        const startTime = Date.now();
-        try {
-            const { limit = 10, state } = args;
-            let query = 'ORDERBYDESCsys_created_on';
-            if (state) {
-                query = `state=${state}^${query}`;
-            }
-            const response = await this.client.makeRequest({
-                method: 'GET',
-                url: '/api/now/table/sys_update_set',
-                params: {
-                    sysparm_query: query,
-                    sysparm_limit: limit,
-                    sysparm_fields: 'sys_id,name,description,state,sys_created_on,sys_created_by'
-                }
-            });
-            return {
-                success: true,
-                result: {
-                    update_sets: response.result,
-                    count: response.result.length,
-                    current_session: this.currentSession?.update_set_id
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to list Update Sets', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to list Update Sets',
-                retryable: false, // Simplified error handling
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async completeUpdateSet(args) {
-        const startTime = Date.now();
-        try {
-            const { update_set_id, notes } = args;
-            const targetId = update_set_id || this.currentSession?.update_set_id;
-            if (!targetId) {
-                throw new Error('No Update Set specified and no active session');
-            }
-            // Update state in ServiceNow
-            const updateData = {
-                state: 'complete',
-                description: notes ? `${this.currentSession?.description}\n\nCompletion Notes: ${notes}` : undefined
-            };
-            await this.makeAuthenticatedRequest({
-                method: 'PATCH',
-                url: `/api/now/table/sys_update_set/${targetId}`,
-                data: updateData
-            });
-            // Update session if it's the current one
-            if (this.currentSession && this.currentSession.update_set_id === targetId) {
-                this.currentSession.state = 'complete';
-                await this.saveSession(this.currentSession);
-                this.currentSession = null; // Clear current session
-            }
-            return {
-                success: true,
-                result: {
-                    update_set_id: targetId,
-                    state: 'complete',
-                    notes: notes || 'Update Set completed'
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to complete Update Set', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to complete Update Set',
-                retryable: false, // Simplified error handling
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async addArtifactToSession(args) {
-        const startTime = Date.now();
-        try {
-            const { type, sys_id, name } = args;
-            if (!this.currentSession) {
-                throw new Error('No active Update Set session. Create or switch to an Update Set first.');
-            }
-            // Add artifact to session
-            const artifact = {
-                type,
-                sys_id,
-                name,
-                created_at: new Date().toISOString()
-            };
-            this.currentSession.artifacts.push(artifact);
-            await this.saveSession(this.currentSession);
-            this.logger.info(`Tracked artifact: ${type} - ${name} (${sys_id})`);
-            return {
-                success: true,
-                result: {
-                    artifact_tracked: true,
-                    update_set_id: this.currentSession.update_set_id,
-                    total_artifacts: this.currentSession.artifacts.length
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to track artifact', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to track artifact',
-                retryable: false,
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async ensureActiveUpdateSet(args) {
-        const startTime = Date.now();
-        try {
-            const { context = 'general development', auto_create = true } = args;
-            // Check if we have an active session
-            if (this.currentSession && this.currentSession.state === 'in_progress') {
-                return {
-                    success: true,
-                    result: {
-                        update_set_id: this.currentSession.update_set_id,
-                        name: this.currentSession.name,
-                        already_active: true
-                    },
-                    executionTime: Date.now() - startTime
-                };
-            }
-            // Check ServiceNow for active Update Sets
-            const response = await this.client.makeRequest({
-                method: 'GET',
-                url: '/api/now/table/sys_update_set',
-                params: {
-                    sysparm_query: 'state=in_progress',
-                    sysparm_limit: 1,
-                    sysparm_fields: 'sys_id,name,description'
-                }
-            });
-            if (response.result && response.result.length > 0) {
-                // Switch to existing Update Set
-                const updateSet = response.result[0];
-                return this.switchUpdateSet({ update_set_id: updateSet.sys_id });
-            }
-            // Auto-create if enabled
-            if (auto_create) {
-                const timestamp = new Date().toISOString().split('T')[0];
-                return this.createUpdateSet({
-                    name: `Auto-created: ${context} - ${timestamp}`,
-                    description: `Automatically created Update Set for ${context}`,
-                    auto_switch: true
-                });
-            }
-            return {
-                success: false,
-                error: 'No active Update Set and auto-create disabled',
-                result: {
-                    recommendation: 'Create an Update Set with snow_update_set_create'
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to ensure active Update Set', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to ensure active Update Set',
-                retryable: false, // Simplified error handling
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async previewUpdateSet(args) {
-        const startTime = Date.now();
-        try {
-            const update_set_id = args.update_set_id || this.currentSession?.update_set_id;
-            if (!update_set_id) {
-                throw new Error('No Update Set specified and no active session');
-            }
-            // Get Update Set details
-            const response = await this.client.makeRequest({
-                method: 'GET',
-                url: `/api/now/table/sys_update_xml`,
-                params: {
-                    sysparm_query: `update_set=${update_set_id}`,
-                    sysparm_fields: 'sys_id,name,type,target_name,action,sys_created_on'
-                }
-            });
-            return {
-                success: true,
-                result: {
-                    update_set_id,
-                    changes_count: response.result.length,
-                    changes: response.result
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to preview Update Set', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to preview Update Set',
-                retryable: false, // Simplified error handling
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    async exportUpdateSet(args) {
-        const startTime = Date.now();
-        try {
-            const { update_set_id, output_path } = args;
-            if (!update_set_id) {
-                throw new Error('Update Set ID is required for export');
-            }
-            // Export Update Set as XML
-            const response = await this.client.makeRequest({
-                method: 'GET',
-                url: `/api/now/table/sys_update_set/${update_set_id}/export`,
-                responseType: 'text'
-            });
-            // Save to file if path provided
-            if (output_path) {
-                await fs_1.promises.writeFile(output_path, response.result);
-            }
-            return {
-                success: true,
-                result: {
-                    update_set_id,
-                    exported: true,
-                    output_path: output_path || 'returned in response',
-                    size: response.result.length
-                },
-                executionTime: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to export Update Set', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to export Update Set',
-                retryable: false, // Simplified error handling
-                executionTime: Date.now() - startTime
-            };
-        }
-    }
-    // Helper methods
-    async switchToUpdateSet(updateSetId) {
-        // Switch Update Set context in ServiceNow
-        await this.client.makeRequest({
-            method: 'PUT',
-            url: `/api/now/table/sys_user_preference`,
-            data: {
-                name: 'sys_update_set',
-                value: updateSetId,
-                user: 'current'
-            }
-        });
-    }
-    async ensureSessionsDirectory() {
-        try {
-            await fs_1.promises.mkdir(this.sessionsPath, { recursive: true });
-        }
-        catch (error) {
-            this.logger.error('Failed to create sessions directory', error);
-        }
-    }
-    async saveSession(session) {
-        const sessionFile = (0, path_1.join)(this.sessionsPath, `${session.update_set_id}.json`);
-        await fs_1.promises.writeFile(sessionFile, JSON.stringify(session, null, 2));
-    }
-    async loadSessionById(updateSetId) {
-        try {
-            const sessionFile = (0, path_1.join)(this.sessionsPath, `${updateSetId}.json`);
-            const content = await fs_1.promises.readFile(sessionFile, 'utf-8');
-            return JSON.parse(content);
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    async loadActiveSession() {
-        try {
-            const files = await fs_1.promises.readdir(this.sessionsPath);
-            for (const file of files) {
-                if (file.endsWith('.json')) {
-                    const sessionFile = (0, path_1.join)(this.sessionsPath, file);
-                    const content = await fs_1.promises.readFile(sessionFile, 'utf-8');
-                    const session = JSON.parse(content);
-                    if (session.active_session && session.state === 'in_progress') {
-                        this.currentSession = session;
-                        this.logger.info(`Loaded active Update Set session: ${session.name}`);
-                        break;
-                    }
-                }
-            }
-        }
-        catch (error) {
-            this.logger.warn('No active Update Set session found');
-        }
-    }
-}
-exports.ServiceNowUpdateSetMCP = ServiceNowUpdateSetMCP;
-// Create and run the server
-if (require.main === module) {
-    const server = new ServiceNowUpdateSetMCP();
-    server.start().catch(console.error);
-}
-//# sourceMappingURL=servicenow-update-set-mcp-refactored.js.map