snow-flow 2.6.4 → 2.6.6

package/dist/mcp/servicenow-deployment-mcp-refactored.js

@@ -1,1044 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Deployment MCP Server - Agent-Integrated Version
- * Provides specialized deployment tools with full agent coordination
- * NEW v1.3.1: Complete XML Update Set auto-import with preview and commit controls
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowDeploymentMCP = void 0;
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const base_mcp_server_js_1 = require("./shared/base-mcp-server.js");
-const scope_manager_js_1 = require("../managers/scope-manager.js");
-const global_scope_strategy_js_1 = require("../strategies/global-scope-strategy.js");
-const artifact_tracker_js_1 = require("../utils/artifact-tracker.js");
-const fs_1 = require("fs");
-class ServiceNowDeploymentMCP extends base_mcp_server_js_1.BaseMCPServer {
-    constructor() {
-        super('servicenow-deployment', '2.0.0');
-        // Initialize scope management
-        this.scopeManager = new scope_manager_js_1.ScopeManager({
-            defaultScope: global_scope_strategy_js_1.ScopeType.GLOBAL,
-            allowFallback: true,
-            validatePermissions: true,
-            enableMigration: false
-        });
-        this.globalScopeStrategy = new global_scope_strategy_js_1.GlobalScopeStrategy();
-        // Start artifact tracking session
-        artifact_tracker_js_1.artifactTracker.startSession();
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        // Define available tools
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'snow_deploy',
-                    description: 'AGENT-AWARE DEPLOYMENT - Complete deployment workflow with automatic update set management, agent coordination, and memory integration',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            type: {
-                                type: 'string',
-                                enum: ['widget', 'flow', 'application', 'script', 'business_rule', 'table', 'batch', 'xml_update_set'],
-                                description: 'Type of artifact to deploy (use xml_update_set for XML import)'
-                            },
-                            xml_file_path: {
-                                type: 'string',
-                                description: 'Path to XML update set file (for xml_update_set type)'
-                            },
-                            auto_preview: {
-                                type: 'boolean',
-                                description: 'Automatically preview the update set after import (default: true)',
-                                default: true
-                            },
-                            auto_commit: {
-                                type: 'boolean',
-                                description: 'Automatically commit the update set if preview is clean (default: true)',
-                                default: true
-                            },
-                            instruction: {
-                                type: 'string',
-                                description: 'Natural language instruction for what to create (for flows/widgets)'
-                            },
-                            config: {
-                                type: 'object',
-                                description: 'Artifact configuration (alternative to instruction for direct config)'
-                            },
-                            artifacts: {
-                                type: 'array',
-                                description: 'For batch deployments - array of artifacts',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        type: { type: 'string' },
-                                        config: { type: 'object' },
-                                        instruction: { type: 'string' }
-                                    }
-                                }
-                            },
-                            // Agent context parameters
-                            session_id: {
-                                type: 'string',
-                                description: 'Agent session ID for coordination'
-                            },
-                            agent_id: {
-                                type: 'string',
-                                description: 'Deploying agent ID'
-                            },
-                            agent_type: {
-                                type: 'string',
-                                description: 'Type of agent performing deployment'
-                            },
-                            // Deployment options
-                            auto_update_set: {
-                                type: 'boolean',
-                                description: 'Automatically ensure active Update Set session (default: true)',
-                                default: true
-                            },
-                            fallback_strategy: {
-                                type: 'string',
-                                enum: ['manual_steps', 'update_set_only', 'none'],
-                                description: 'Strategy when direct deployment fails (default: manual_steps)',
-                                default: 'manual_steps'
-                            },
-                            permission_escalation: {
-                                type: 'string',
-                                enum: ['auto_request', 'manual', 'none'],
-                                description: 'How to handle permission errors (default: auto_request)',
-                                default: 'auto_request'
-                            },
-                            deployment_context: {
-                                type: 'string',
-                                description: 'Context for Update Set naming (e.g., "incident widget", "approval flow")'
-                            },
-                            // Batch options
-                            parallel: {
-                                type: 'boolean',
-                                description: 'Deploy batch artifacts in parallel',
-                                default: false
-                            },
-                            transaction_mode: {
-                                type: 'boolean',
-                                description: 'All-or-nothing batch deployment',
-                                default: true
-                            },
-                            dry_run: {
-                                type: 'boolean',
-                                description: 'Validate without deploying',
-                                default: false
-                            }
-                        },
-                        required: ['type']
-                    }
-                },
-                {
-                    name: 'snow_deployment_status',
-                    description: 'Check deployment status and history with agent tracking',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            session_id: { type: 'string', description: 'Session ID to filter by' },
-                            limit: { type: 'number', description: 'Number of recent deployments to show', default: 10 },
-                        }
-                    }
-                },
-                {
-                    name: 'snow_validate_deployment',
-                    description: 'Validate a deployment before executing with agent coordination',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            type: { type: 'string', enum: ['widget', 'workflow', 'application'] },
-                            artifact: { type: 'object', description: 'The artifact to validate' },
-                            session_id: { type: 'string' },
-                            agent_id: { type: 'string' }
-                        },
-                        required: ['type', 'artifact']
-                    }
-                },
-                {
-                    name: 'snow_rollback_deployment',
-                    description: 'Rollback a deployment with agent coordination',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            update_set_id: { type: 'string', description: 'Update set sys_id to rollback' },
-                            reason: { type: 'string', description: 'Reason for rollback' },
-                            session_id: { type: 'string' },
-                            agent_id: { type: 'string' }
-                        },
-                        required: ['update_set_id', 'reason']
-                    }
-                }
-            ]
-        }));
-        // Handle tool calls
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request, extra) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case 'snow_deploy':
-                        return await this.deployWithAgentCoordination(args);
-                    case 'snow_deployment_status':
-                        return await this.getDeploymentStatusWithContext(args);
-                    case 'snow_validate_deployment':
-                        return await this.validateDeploymentWithContext(args);
-                    case 'snow_rollback_deployment':
-                        return await this.rollbackDeploymentWithContext(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                return this.createErrorResponse(`Tool execution failed: ${name}`, error);
-            }
-        });
-    }
-    /**
-     * Main deployment method with full agent integration and intelligent workflow
-     */
-    async deployWithAgentCoordination(args) {
-        return await this.executeWithAgentContext('snow_deploy', args, async (context) => {
-            // 🔧 STEP 1: MANDATORY Authentication and Connection Validation
-            this.logger.info('🔍 Step 1: Validating ServiceNow connection...');
-            const connectionResult = await this.validateServiceNowConnection();
-            if (!connectionResult.success) {
-                return this.createAuthenticationError(connectionResult.error);
-            }
-            // Assert no mock data
-            this.assertNoMockData('deployment');
-            // 🔧 STEP 2: Update Set Management
-            this.logger.info('📦 Step 2: Ensuring Update Set for tracking...');
-            await this.reportProgress(context, 15, 'Setting up Update Set');
-            const purpose = args.type === 'batch' ? 'Batch Deployment' : `${args.type} Deployment`;
-            const updateSetId = await this.ensureUpdateSet(context, purpose);
-            if (!updateSetId) {
-                this.logger.warn('⚠️ No Update Set created - changes will not be tracked');
-            }
-            // 🔧 STEP 3: Smart Artifact Discovery (DRY principle)
-            if (args.type !== 'batch' && (args.config?.name || args.instruction)) {
-                this.logger.info('🔍 Step 3: Discovering existing artifacts...');
-                await this.reportProgress(context, 25, 'Checking for existing artifacts');
-                const artifactName = args.config?.name || this.extractNameFromInstruction(args.instruction);
-                if (artifactName) {
-                    const discovery = await this.discoverExistingArtifacts(args.type, artifactName, this.extractSearchTermsFromInstruction(args.instruction));
-                    if (discovery.found) {
-                        this.logger.info(`🔍 Found ${discovery.artifacts.length} existing artifacts`);
-                        // Store discovery info in memory for reference
-                        await this.memory.updateSharedContext({
-                            session_id: context.session_id,
-                            context_key: `discovery_${args.type}`,
-                            context_value: JSON.stringify({
-                                artifacts: discovery.artifacts,
-                                suggestions: discovery.suggestions,
-                                timestamp: new Date().toISOString()
-                            }),
-                            created_by_agent: context.agent_id
-                        });
-                    }
-                }
-            }
-            // Get session context for coordination
-            const sessionContext = await this.getSessionContext(context.session_id);
-            // Report progress
-            await this.reportProgress(context, 35, 'Starting deployment');
-            try {
-                // Handle different deployment types
-                let result;
-                if (args.type === 'batch') {
-                    result = await this.deployBatch(args, context, updateSetId);
-                }
-                else if (args.type === 'xml_update_set') {
-                    result = await this.deployXMLUpdateSet(args, context);
-                }
-                else {
-                    result = await this.deploySingleArtifact(args, context, updateSetId);
-                }
-                // Add discovery information to successful results (from memory context)
-                try {
-                    const discoveryResults = await this.memory.query('SELECT context_value FROM shared_context WHERE session_id = ? AND context_key = ?', [context.session_id, `discovery_${args.type}`]);
-                    if (discoveryResults.length > 0) {
-                        const discovery = JSON.parse(discoveryResults[0].context_value);
-                        if (discovery.artifacts && discovery.artifacts.length > 0) {
-                            result.content.push({
-                                type: 'text',
-                                text: `\n📋 Artifact Discovery Results:\n${discovery.suggestions?.join('\n') || ''}`
-                            });
-                        }
-                    }
-                }
-                catch (discoveryError) {
-                    this.logger.warn('Could not retrieve discovery information', discoveryError);
-                }
-                return result;
-            }
-            catch (error) {
-                this.logger.error('Deployment failed, attempting intelligent recovery...', error);
-                // Use enhanced error handling with fallback options
-                const fallbackOptions = {
-                    enableRetry: true,
-                    enableScopeEscalation: args.permission_escalation === 'auto_request',
-                    enableManualSteps: args.fallback_strategy === 'manual_steps'
-                };
-                const errorResult = await this.handleServiceNowError(error, `${args.type} deployment`, context, fallbackOptions);
-                // If error handling provided a recovery solution
-                if (errorResult.content.some(c => c.text?.includes('can_continue: true'))) {
-                    this.logger.info('✅ Error recovered - retrying deployment...');
-                    try {
-                        // Retry the deployment after recovery
-                        await this.reportProgress(context, 85, 'Retrying after error recovery');
-                        let retryResult;
-                        if (args.type === 'batch') {
-                            retryResult = await this.deployBatch(args, context, updateSetId);
-                        }
-                        else {
-                            retryResult = await this.deploySingleArtifact(args, context, updateSetId);
-                        }
-                        // Add recovery note to success result
-                        retryResult.content.push({
-                            type: 'text',
-                            text: '\n✅ Deployment succeeded after automatic error recovery'
-                        });
-                        return retryResult;
-                    }
-                    catch (retryError) {
-                        this.logger.error('Retry after recovery also failed', retryError);
-                        // Request Queen intervention for persistent failures
-                        await this.requestQueenIntervention(context, {
-                            type: 'deployment_failure_persistent',
-                            priority: 'critical',
-                            description: `Failed to deploy ${args.type} even after error recovery: ${retryError instanceof Error ? retryError.message : String(retryError)}`,
-                            attempted_solutions: ['direct_deployment', 'error_recovery', 'retry_after_recovery']
-                        });
-                        return errorResult; // Return the error recovery guidance
-                    }
-                }
-                // If no automatic recovery possible, request Queen intervention
-                await this.requestQueenIntervention(context, {
-                    type: 'deployment_failure',
-                    priority: 'high',
-                    description: `Failed to deploy ${args.type}: ${error instanceof Error ? error.message : String(error)}`,
-                    attempted_solutions: ['direct_deployment', 'intelligent_error_handling']
-                });
-                return errorResult; // Return the error recovery guidance instead of throwing
-            }
-        });
-    }
-    /**
-     * Deploy a single artifact with memory tracking
-     */
-    async deploySingleArtifact(args, context, updateSetId) {
-        const { type, config, instruction } = args;
-        // Report planning phase
-        await this.reportProgress(context, 20, 'Planning deployment');
-        // Ensure update set if requested
-        let finalUpdateSetId = updateSetId;
-        if (args.auto_update_set !== false && !finalUpdateSetId) {
-            finalUpdateSetId = await this.ensureUpdateSet(context, config?.name || 'artifact');
-            await this.reportProgress(context, 30, 'Update set ready');
-        }
-        // Deploy based on type
-        let result;
-        await this.reportProgress(context, 50, `Deploying ${type}`);
-        switch (type) {
-            case 'widget':
-                result = await this.deployWidget(config, context, finalUpdateSetId);
-                break;
-            case 'flow':
-                result = await this.deployFlow(config || { instruction }, context, finalUpdateSetId);
-                break;
-            case 'application':
-                result = await this.deployApplication(config, context, finalUpdateSetId);
-                break;
-            case 'script':
-            case 'business_rule':
-                result = await this.deployScript(type, config, context, finalUpdateSetId);
-                break;
-            case 'xml_update_set':
-                result = await this.deployXMLUpdateSet(config, context);
-                break;
-            default:
-                throw new Error(`Unsupported deployment type: ${type}`);
-        }
-        // Store artifact in memory
-        await this.storeArtifact(context, {
-            sys_id: result.sys_id,
-            type,
-            name: result.name || config?.name || 'unnamed',
-            description: config?.description,
-            config,
-            update_set_id: finalUpdateSetId
-        });
-        // Record deployment in history
-        await this.memory.recordDeployment(context.session_id, result.sys_id, type, true, context.agent_id);
-        await this.reportProgress(context, 90, 'Finalizing deployment');
-        // Notify next agent if needed
-        if (result.next_agent) {
-            await this.notifyHandoff(context, result.next_agent, {
-                type,
-                sys_id: result.sys_id,
-                next_steps: result.next_steps || []
-            });
-        }
-        await this.reportProgress(context, 100, 'Deployment complete');
-        return this.createSuccessResponse(`Successfully deployed ${type}: ${result.name}`, {
-            sys_id: result.sys_id,
-            name: result.name,
-            update_set_id: finalUpdateSetId,
-            deployment_details: result
-        }, {
-            agent_id: context.agent_id,
-            session_id: context.session_id,
-            artifacts_created: [result.sys_id]
-        });
-    }
-    /**
-     * Deploy multiple artifacts in batch
-     */
-    async deployBatch(args, context, updateSetId) {
-        const { artifacts, parallel, transaction_mode, dry_run } = args;
-        if (!artifacts || !Array.isArray(artifacts)) {
-            throw new Error('Batch deployment requires artifacts array');
-        }
-        await this.reportProgress(context, 10, `Preparing batch deployment of ${artifacts.length} artifacts`);
-        // Dry run validation
-        if (dry_run) {
-            const validationResults = await Promise.all(artifacts.map(artifact => this.validateArtifact(artifact, context)));
-            return this.createSuccessResponse('Dry run completed - all artifacts validated', { validationResults });
-        }
-        // Create update set for batch
-        const batchUpdateSetId = await this.ensureUpdateSet(context, `Batch deployment`);
-        const results = [];
-        const errors = [];
-        try {
-            if (parallel) {
-                // Deploy in parallel
-                await this.reportProgress(context, 30, 'Deploying artifacts in parallel');
-                const deploymentPromises = artifacts.map((artifact, index) => this.deploySingleArtifact({ ...artifact, auto_update_set: false }, context).catch(error => {
-                    errors.push({ artifact, error: error.message });
-                    return null;
-                }));
-                const parallelResults = await Promise.all(deploymentPromises);
-                results.push(...parallelResults.filter(r => r !== null));
-            }
-            else {
-                // Deploy sequentially
-                for (let i = 0; i < artifacts.length; i++) {
-                    const artifact = artifacts[i];
-                    await this.reportProgress(context, 30 + (60 * i / artifacts.length), `Deploying artifact ${i + 1} of ${artifacts.length}`);
-                    try {
-                        const result = await this.deploySingleArtifact({ ...artifact, auto_update_set: false }, context);
-                        results.push(result);
-                    }
-                    catch (error) {
-                        errors.push({ artifact, error: error instanceof Error ? error.message : String(error) });
-                        if (transaction_mode) {
-                            // Rollback on error in transaction mode
-                            await this.rollbackBatch(results, batchUpdateSetId, context);
-                            throw new Error(`Batch deployment failed at artifact ${i + 1}: ${error}`);
-                        }
-                    }
-                }
-            }
-            // Check if we need to rollback
-            if (transaction_mode && errors.length > 0) {
-                await this.rollbackBatch(results, batchUpdateSetId, context);
-                throw new Error(`Batch deployment failed with ${errors.length} errors`);
-            }
-            await this.reportProgress(context, 100, 'Batch deployment complete');
-            return this.createSuccessResponse(`Batch deployment completed: ${results.length} succeeded, ${errors.length} failed`, {
-                successful: results.length,
-                failed: errors.length,
-                errors: errors.length > 0 ? errors : undefined,
-                update_set_id: batchUpdateSetId
-            });
-        }
-        catch (error) {
-            // Record failed deployment
-            await this.memory.recordDeployment(context.session_id, 'batch_deployment', 'batch', false, context.agent_id, error instanceof Error ? error.message : String(error));
-            throw error;
-        }
-    }
-    /**
-     * Deploy XML Update Set to ServiceNow
-     */
-    async deployXMLUpdateSet(args, context) {
-        const { xml_file_path, auto_preview = true, auto_commit = true } = args;
-        if (!xml_file_path) {
-            throw new Error('XML file path is required for xml_update_set deployment');
-        }
-        this.logger.info('🚀 Deploying XML Update Set', {
-            file: xml_file_path,
-            auto_preview,
-            auto_commit
-        });
-        try {
-            // Read XML file
-            await this.reportProgress(context, 20, 'Reading XML file');
-            const xmlContent = await fs_1.promises.readFile(xml_file_path, 'utf-8');
-            // Import XML as remote update set
-            await this.reportProgress(context, 40, 'Importing XML to ServiceNow');
-            const importResponse = await this.client.makeRequest({
-                method: 'POST',
-                url: '/api/now/table/sys_remote_update_set',
-                headers: {
-                    'Content-Type': 'application/xml',
-                    'Accept': 'application/json'
-                },
-                data: xmlContent
-            });
-            if (!importResponse.result || !importResponse.result.sys_id) {
-                throw new Error('Failed to import XML update set');
-            }
-            const remoteUpdateSetId = importResponse.result.sys_id;
-            this.logger.info('✅ XML imported successfully', { sys_id: remoteUpdateSetId });
-            // Load the update set
-            await this.reportProgress(context, 60, 'Loading update set');
-            await this.client.makeRequest({
-                method: 'PUT',
-                url: `/api/now/table/sys_remote_update_set/${remoteUpdateSetId}`,
-                data: {
-                    state: 'loaded'
-                }
-            });
-            // Find the loaded update set
-            const loadedResponse = await this.client.makeRequest({
-                method: 'GET',
-                url: '/api/now/table/sys_update_set',
-                params: {
-                    sysparm_query: `remote_sys_id=${remoteUpdateSetId}`,
-                    sysparm_limit: 1
-                }
-            });
-            if (!loadedResponse.result || loadedResponse.result.length === 0) {
-                throw new Error('Failed to find loaded update set');
-            }
-            const updateSetId = loadedResponse.result[0].sys_id;
-            const updateSetName = loadedResponse.result[0].name;
-            // Preview if requested
-            if (auto_preview) {
-                await this.reportProgress(context, 80, 'Previewing update set');
-                const previewResponse = await this.client.makeRequest({
-                    method: 'POST',
-                    url: `/api/now/table/sys_update_set/${updateSetId}/preview`
-                });
-                // Check preview results
-                const previewProblems = await this.client.makeRequest({
-                    method: 'GET',
-                    url: '/api/now/table/sys_update_preview_problem',
-                    params: {
-                        sysparm_query: `update_set=${updateSetId}`,
-                        sysparm_limit: 100
-                    }
-                });
-                if (previewProblems.result && previewProblems.result.length > 0) {
-                    const problems = previewProblems.result.map((p) => `- ${p.type}: ${p.description}`).join('\n');
-                    if (auto_commit) {
-                        this.logger.warn('Preview found problems, skipping auto-commit', { problems });
-                    }
-                    return this.createSuccessResponse('XML imported and previewed with problems', {
-                        update_set_id: updateSetId,
-                        update_set_name: updateSetName,
-                        preview_status: 'problems_found',
-                        problems: previewProblems.result,
-                        next_steps: [
-                            '1. Review preview problems in ServiceNow',
-                            '2. Resolve any issues',
-                            '3. Commit manually when ready'
-                        ]
-                    });
-                }
-                // Commit if clean and requested
-                if (auto_commit) {
-                    await this.reportProgress(context, 95, 'Committing update set');
-                    await this.client.makeRequest({
-                        method: 'POST',
-                        url: `/api/now/table/sys_update_set/${updateSetId}/commit`
-                    });
-                    return this.createSuccessResponse('✅ XML Update Set imported, previewed, and committed successfully!', {
-                        update_set_id: updateSetId,
-                        update_set_name: updateSetName,
-                        status: 'committed',
-                        flow_location: 'Flow Designer > Designer',
-                        next_steps: [
-                            '1. Navigate to Flow Designer',
-                            '2. Your flow should be visible in the list',
-                            '3. Open the flow to verify all components'
-                        ]
-                    });
-                }
-            }
-            // Return success without preview/commit
-            return this.createSuccessResponse('XML Update Set imported successfully', {
-                update_set_id: updateSetId,
-                update_set_name: updateSetName,
-                status: 'imported',
-                next_steps: [
-                    '1. Navigate to System Update Sets > Local Update Sets',
-                    '2. Find your update set: ' + updateSetName,
-                    '3. Click Preview Update Set',
-                    '4. Review and commit when ready'
-                ]
-            });
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            if (errorMsg.includes('ENOENT')) {
-                throw new Error(`XML file not found: ${xml_file_path}`);
-            }
-            throw new Error(`Failed to deploy XML update set: ${errorMsg}`);
-        }
-    }
-    /**
-     * Deploy widget with agent tracking and intelligent error handling
-     */
-    async deployWidget(config, context, updateSetId) {
-        this.logger.info('Deploying widget', {
-            name: config.name,
-            agent_id: context.agent_id
-        });
-        try {
-            // Validate widget configuration first
-            const validationErrors = this.validateWidgetConfig(config);
-            if (validationErrors.length > 0) {
-                throw new Error(`Widget validation failed: ${validationErrors.join(', ')}`);
-            }
-            // Create widget in ServiceNow
-            const widgetData = {
-                name: config.name,
-                id: config.name,
-                template: config.template || '<div>Widget Template</div>',
-                css: config.css || '',
-                server_script: config.server_script || '',
-                client_script: config.client_script || '',
-                public: false,
-                roles: '',
-                active: true
-            };
-            const response = await this.client.createRecord('sp_widget', widgetData);
-            if (!response.success || !response.result) {
-                // Try to provide more specific error information
-                const errorMsg = response.error || 'Unknown error creating widget';
-                // Check for common widget creation issues
-                if (errorMsg.includes('duplicate') || errorMsg.includes('already exists')) {
-                    throw new Error(`Widget '${config.name}' already exists. Consider using a different name or updating the existing widget.`);
-                }
-                if (errorMsg.includes('permission') || errorMsg.includes('access') || errorMsg.includes('403')) {
-                    throw new Error(`
-🚫 Service Portal Permission Error (403)
-
-Even with sp_admin role, this can happen due to:
-
-1. **OAuth Scope Restrictions**
-   - Go to: System OAuth > Application Registry
-   - Set "Accessible from" to "All application scopes"
-
-2. **Cross-Scope Access** 
-   - Switch to Global scope and try again
-   - Check ACLs on sp_widget table
-
-3. **Missing System Properties**
-   - Ensure: glide.service_portal.enable_api_access = true
-
-4. **Update Set Required**
-   - Widgets must be created in an active Update Set
-   - Use: snow_ensure_active_update_set() first
-
-🔧 Quick Fix: Try deployment with global scope:
-await snow_deploy({
-  type: "widget", 
-  config: {...},
-  scope_preference: "global"
-});
-
-📚 See SERVICE_PORTAL_403_FIX.md for detailed troubleshooting.
-          `);
-                }
-                throw new Error(`Failed to create widget in ServiceNow: ${errorMsg}`);
-            }
-            const result = response.result;
-            const widgetSysId = Array.isArray(result) ? result[0]?.sys_id : result?.sys_id;
-            // 🔧 Track artifact in Update Set
-            if (updateSetId) {
-                try {
-                    await this.trackArtifact(widgetSysId, 'widget', config.name, updateSetId);
-                }
-                catch (trackingError) {
-                    this.logger.warn('Update Set tracking failed (widget created but not tracked)', trackingError);
-                    // Don't fail the deployment, just warn
-                }
-            }
-            // Determine next agent based on widget complexity
-            let nextAgent;
-            let nextSteps = [];
-            if (config.requires_styling || config.template?.includes('class=')) {
-                nextAgent = 'ui_specialist';
-                nextSteps = ['responsive_styling', 'accessibility_compliance'];
-            }
-            else if (config.requires_testing) {
-                nextAgent = 'test_agent';
-                nextSteps = ['functional_testing', 'performance_testing'];
-            }
-            // Log successful deployment
-            this.logger.info(`✅ Widget deployed successfully: ${config.name} (${widgetSysId})`);
-            return {
-                sys_id: widgetSysId,
-                name: config.name,
-                table: 'sp_widget',
-                next_agent: nextAgent,
-                next_steps: nextSteps,
-                success: true
-            };
-        }
-        catch (error) {
-            this.logger.error('Widget deployment failed', error);
-            // Use intelligent error handling for specific recovery guidance
-            const errorResult = await this.handleServiceNowError(error, 'widget deployment', context, {
-                enableRetry: true,
-                enableScopeEscalation: true,
-                enableManualSteps: true
-            });
-            // Re-throw with enhanced error information for higher-level handling
-            const enhancedError = new Error(`Widget deployment failed: ${error instanceof Error ? error.message : String(error)}`);
-            enhancedError.errorRecoveryGuidance = errorResult;
-            throw enhancedError;
-        }
-    }
-    /**
-     * Validate widget configuration before deployment
-     */
-    validateWidgetConfig(config) {
-        const errors = [];
-        if (!config.name) {
-            errors.push('Widget name is required');
-        }
-        else {
-            // Check for valid widget naming
-            if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(config.name)) {
-                errors.push('Widget name must start with letter and contain only letters, numbers, and underscores');
-            }
-            if (config.name.length > 40) {
-                errors.push('Widget name must be 40 characters or less');
-            }
-        }
-        if (!config.template) {
-            errors.push('Widget template is required');
-        }
-        else {
-            // Basic HTML validation
-            if (config.template.length > 100000) {
-                errors.push('Widget template is too large (max 100KB)');
-            }
-        }
-        // Validate scripts if provided
-        if (config.server_script && config.server_script.length > 1000000) {
-            errors.push('Server script is too large (max 1MB)');
-        }
-        if (config.client_script && config.client_script.length > 1000000) {
-            errors.push('Client script is too large (max 1MB)');
-        }
-        return errors;
-    }
-    /**
-     * Deploy flow with agent tracking
-     */
-    async deployFlow(config, context, updateSetId) {
-        // For flows with natural language instructions, delegate to flow composer
-        if (config.instruction) {
-            // Store instruction in shared context for flow builder agent
-            await this.memory.updateSharedContext({
-                session_id: context.session_id,
-                context_key: 'flow_instruction',
-                context_value: config.instruction,
-                created_by_agent: context.agent_id
-            });
-            return {
-                sys_id: `pending_flow_${Date.now()}`,
-                name: 'Flow from instruction',
-                instruction: config.instruction,
-                next_agent: 'flow_builder',
-                next_steps: ['analyze_requirements', 'create_flow_structure', 'deploy_flow']
-            };
-        }
-        // Direct flow deployment
-        const flowData = {
-            name: config.name,
-            description: config.description,
-            active: config.active !== false,
-            sys_scope: 'global'
-        };
-        const response = await this.client.createRecord('sys_hub_flow', flowData);
-        if (!response.success || !response.result) {
-            throw new Error('Failed to create flow in ServiceNow');
-        }
-        const result = response.result;
-        return {
-            sys_id: Array.isArray(result) ? result[0]?.sys_id : result?.sys_id,
-            name: config.name,
-            table: 'sys_hub_flow'
-        };
-    }
-    /**
-     * Deploy application with scope management
-     */
-    async deployApplication(config, context, updateSetId) {
-        // Determine deployment scope (simplified)
-        const scopeStrategy = config.scope_strategy || 'auto';
-        const targetScope = scopeStrategy === 'auto' ? 'global' : (config.scope || 'global');
-        const appData = {
-            name: config.name,
-            scope: targetScope,
-            short_description: config.short_description,
-            version: config.version,
-            vendor: config.vendor || 'Custom',
-            vendor_prefix: config.vendor_prefix || 'x',
-            active: config.active !== false
-        };
-        const response = await this.client.createRecord('sys_app', appData);
-        if (!response.success || !response.result) {
-            throw new Error('Failed to create application in ServiceNow');
-        }
-        const result = response.result;
-        return {
-            sys_id: Array.isArray(result) ? result[0]?.sys_id : result?.sys_id,
-            name: config.name,
-            scope: targetScope,
-            table: 'sys_app'
-        };
-    }
-    /**
-     * Deploy script or business rule
-     */
-    async deployScript(type, config, context, updateSetId) {
-        const table = type === 'script' ? 'sys_script' : 'sys_script';
-        const scriptData = {
-            name: config.name,
-            script: config.script,
-            active: config.active !== false,
-            description: config.description
-        };
-        const response = await this.client.createRecord(table, scriptData);
-        if (!response.success || !response.result) {
-            throw new Error(`Failed to create ${type} in ServiceNow`);
-        }
-        // Scripts often need testing
-        const result = response.result;
-        return {
-            sys_id: Array.isArray(result) ? result[0]?.sys_id : result?.sys_id,
-            name: config.name,
-            table,
-            next_agent: 'test_agent',
-            next_steps: ['syntax_validation', 'unit_testing']
-        };
-    }
-    /**
-     * Get deployment status with session filtering
-     */
-    async getDeploymentStatusWithContext(args) {
-        return await this.executeWithAgentContext('snow_deployment_status', args, async (context) => {
-            const session_id = args.session_id || context.session_id;
-            // Get artifacts from memory
-            const artifacts = await this.memory.getSessionArtifacts(session_id);
-            // Get active agents
-            const activeAgents = await this.memory.query(`
-          SELECT * FROM agent_coordination 
-          WHERE session_id = ? 
-          ORDER BY last_activity DESC
-        `, [session_id]);
-            // Get recent deployments
-            const deployments = await this.memory.query(`
-          SELECT * FROM deployment_history 
-          WHERE session_id = ? 
-          ORDER BY deployment_time DESC 
-          LIMIT ?
-        `, [session_id, args.limit || 10]);
-            return this.createSuccessResponse(`Deployment status for session ${session_id}`, {
-                artifacts: artifacts.length,
-                active_agents: activeAgents.length,
-                recent_deployments: deployments,
-                session_summary: {
-                    total_artifacts: artifacts.length,
-                    artifact_types: this.groupByType(artifacts),
-                    success_rate: this.calculateSuccessRate(deployments)
-                }
-            });
-        });
-    }
-    /**
-     * Validate deployment with agent context
-     */
-    async validateDeploymentWithContext(args) {
-        return await this.executeWithAgentContext('snow_validate_deployment', args, async (context) => {
-            const { type, artifact } = args;
-            const validationResult = await this.validateArtifact({ type, config: artifact }, context);
-            if (validationResult.valid) {
-                return this.createSuccessResponse(`Validation passed for ${type}`, validationResult);
-            }
-            else {
-                // Store validation failure in context
-                await this.memory.updateSharedContext({
-                    session_id: context.session_id,
-                    context_key: `validation_failure_${type}`,
-                    context_value: JSON.stringify(validationResult),
-                    created_by_agent: context.agent_id
-                });
-                return this.createErrorResponse(`Validation failed for ${type}`, validationResult.errors);
-            }
-        });
-    }
-    /**
-     * Rollback deployment with coordination
-     */
-    async rollbackDeploymentWithContext(args) {
-        return await this.executeWithAgentContext('snow_rollback_deployment', args, async (context) => {
-            const { update_set_id, reason } = args;
-            // Notify all agents about rollback
-            await this.memory.sendAgentMessage({
-                session_id: context.session_id,
-                from_agent: context.agent_id,
-                to_agent: 'all',
-                message_type: 'status_update',
-                content: JSON.stringify({
-                    action: 'rollback_initiated',
-                    update_set_id,
-                    reason
-                })
-            });
-            // Perform rollback
-            const rollbackResult = await this.client.updateRecord('sys_update_set', update_set_id, {
-                state: 'reverted',
-                description: `Rolled back: ${reason}`
-            });
-            if (rollbackResult.success) {
-                // Update deployment history
-                await this.memory.recordDeployment(context.session_id, update_set_id, 'rollback', true, context.agent_id);
-                return this.createSuccessResponse(`Successfully rolled back update set ${update_set_id}`, { reason });
-            }
-            else {
-                throw new Error('Rollback failed');
-            }
-        });
-    }
-    // Helper methods
-    async validateArtifact(artifact, context) {
-        // Simplified validation logic
-        const errors = [];
-        if (!artifact.type)
-            errors.push('Missing artifact type');
-        if (!artifact.config && !artifact.instruction)
-            errors.push('Missing configuration or instruction');
-        if (artifact.type === 'widget') {
-            if (!artifact.config?.name)
-                errors.push('Widget name is required');
-            if (!artifact.config?.template)
-                errors.push('Widget template is required');
-        }
-        return {
-            valid: errors.length === 0,
-            errors,
-            warnings: []
-        };
-    }
-    async rollbackBatch(results, updateSetId, context) {
-        // Rollback logic for batch deployments
-        for (const result of results) {
-            if (result?.data?.sys_id) {
-                try {
-                    await this.client.deleteRecord(result.data.table || 'sys_metadata', result.data.sys_id);
-                }
-                catch (error) {
-                    this.logger.error('Failed to rollback artifact', error);
-                }
-            }
-        }
-    }
-    groupByType(artifacts) {
-        return artifacts.reduce((acc, artifact) => {
-            acc[artifact.artifact_type] = (acc[artifact.artifact_type] || 0) + 1;
-            return acc;
-        }, {});
-    }
-    calculateSuccessRate(deployments) {
-        if (deployments.length === 0)
-            return 0;
-        const successful = deployments.filter(d => d.success).length;
-        return Math.round((successful / deployments.length) * 100);
-    }
-    /**
-     * Extract artifact name from natural language instruction
-     */
-    extractNameFromInstruction(instruction) {
-        if (!instruction)
-            return null;
-        // Look for patterns like "create a widget called X" or "make a flow named Y"
-        const patterns = [
-            /(?:create|make|build)\s+(?:a|an)?\s*\w+\s+(?:called|named|for)\s+["']?([^"']+)["']?/i,
-            /(?:create|make|build)\s+["']([^"']+)["']\s+\w+/i,
-            /(?:widget|flow|script|rule|table|application)\s+(?:called|named|for)\s+["']?([^"']+)["']?/i,
-            /"([^"]+)"\s+(?:widget|flow|script|rule|table|application)/i,
-            /'([^']+)'\s+(?:widget|flow|script|rule|table|application)/i
-        ];
-        for (const pattern of patterns) {
-            const match = instruction.match(pattern);
-            if (match && match[1]) {
-                return match[1].trim();
-            }
-        }
-        // Fallback: look for quoted text that might be a name
-        const quotedMatch = instruction.match(/["']([^"']{3,30})["']/);
-        if (quotedMatch && quotedMatch[1]) {
-            return quotedMatch[1].trim();
-        }
-        return null;
-    }
-    /**
-     * Extract search terms from instruction for discovery
-     */
-    extractSearchTermsFromInstruction(instruction) {
-        if (!instruction)
-            return [];
-        const terms = [];
-        // Common keywords that might indicate similar functionality
-        const keywords = [
-            'incident', 'dashboard', 'report', 'approval', 'notification', 'user', 'profile',
-            'management', 'tracking', 'monitoring', 'analytics', 'workflow', 'request',
-            'ticket', 'service', 'catalog', 'portal', 'form', 'table', 'list', 'chart',
-            'graph', 'widget', 'flow', 'automation', 'integration', 'api', 'rest',
-            'email', 'alert', 'escalation', 'assignment', 'routing', 'sla', 'metric'
-        ];
-        const lowercaseInstruction = instruction.toLowerCase();
-        // Extract keywords that appear in the instruction
-        for (const keyword of keywords) {
-            if (lowercaseInstruction.includes(keyword)) {
-                terms.push(keyword);
-            }
-        }
-        // Extract quoted terms
-        const quotedTerms = instruction.match(/["']([^"']{2,20})["']/g);
-        if (quotedTerms) {
-            quotedTerms.forEach(quoted => {
-                const term = quoted.replace(/["']/g, '').trim();
-                if (term.length >= 2 && !terms.includes(term.toLowerCase())) {
-                    terms.push(term.toLowerCase());
-                }
-            });
-        }
-        // Extract important words (3+ characters, not common words)
-        const words = lowercaseInstruction.match(/\b[a-z]{3,}\b/g) || [];
-        const commonWords = ['the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had', 'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'man', 'new', 'now', 'old', 'see', 'two', 'who', 'boy', 'did', 'its', 'let', 'put', 'say', 'she', 'too', 'use'];
-        for (const word of words) {
-            if (!commonWords.includes(word) && word.length >= 3 && !terms.includes(word)) {
-                terms.push(word);
-            }
-        }
-        return terms.slice(0, 5); // Limit to 5 terms to avoid too many searches
-    }
-}
-exports.ServiceNowDeploymentMCP = ServiceNowDeploymentMCP;
-// Start the server
-if (require.main === module) {
-    const server = new ServiceNowDeploymentMCP();
-    server.start().catch(console.error);
-}
-//# sourceMappingURL=servicenow-deployment-mcp-refactored.js.map