snow-flow 1.1.71 → 1.1.74

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

@@ -46,7 +46,7 @@ class ServiceNowDeploymentMCP {
             tools: [
                 {
                     name: 'snow_deploy_widget',
-                    description: 'AUTONOMOUS widget deployment - deploys directly to ServiceNow, returns live URLs, handles errors automatically. NO MANUAL STEPS!',
+                    description: '⚠️ DEPRECATED - Use snow_deploy instead. This tool redirects to the unified deployment system.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -66,7 +66,7 @@ class ServiceNowDeploymentMCP {
                 },
                 {
                     name: 'snow_deploy_flow',
-                    description: 'AUTONOMOUS flow deployment - creates complete flows with linked artifacts, auto-deploys dependencies, self-healing. FULLY AUTOMATED!',
+                    description: '⚠️ DEPRECATED - Use snow_deploy instead. This tool redirects to the unified deployment system.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -86,7 +86,7 @@ class ServiceNowDeploymentMCP {
                 },
                 {
                     name: 'snow_deploy_application',
-                    description: 'INTELLIGENT scope-aware application deployment - automatically selects optimal scope (global/application), validates permissions, handles fallbacks',
+                    description: '⚠️ DEPRECATED - Use snow_deploy instead. This tool redirects to the unified deployment system.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -370,7 +370,7 @@ class ServiceNowDeploymentMCP {
                 },
                 {
                     name: 'snow_bulk_deploy',
-                    description: 'Deploy multiple artifacts in a single operation with transaction support',
+                    description: '⚠️ DEPRECATED - Use snow_deploy with batch configuration instead. This tool redirects to the unified deployment system.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -397,6 +397,50 @@ class ServiceNowDeploymentMCP {
                         required: ['artifacts'],
                     },
                 },
+                {
+                    name: 'snow_deploy',
+                    description: 'DEPLOYMENT TOOL - Complete deployment workflow with automatic update set management, permission handling, and resilient fallbacks',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            type: {
+                                type: 'string',
+                                enum: ['widget', 'flow', 'application', 'script', 'business_rule', 'table'],
+                                description: 'Type of artifact to deploy'
+                            },
+                            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)'
+                            },
+                            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")'
+                            }
+                        },
+                        required: ['type']
+                    }
+                },
             ],
         }));
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
@@ -407,11 +451,17 @@ class ServiceNowDeploymentMCP {
                 // and fail gracefully when tools are actually used
                 switch (name) {
                     case 'snow_deploy_widget':
-                        return await this.deployWidget(args);
+                        // Deprecated - redirect to unified deploy
+                        this.logger.warn('snow_deploy_widget is deprecated, redirecting to snow_deploy');
+                        return await this.handleDeprecatedWidgetDeploy(args);
                     case 'snow_deploy_flow':
-                        return await this.deployFlow(args);
+                        // Deprecated - redirect to unified deploy
+                        this.logger.warn('snow_deploy_flow is deprecated, redirecting to snow_deploy');
+                        return await this.handleDeprecatedFlowDeploy(args);
                     case 'snow_deploy_application':
-                        return await this.deployApplication(args);
+                        // Deprecated - redirect to unified deploy
+                        this.logger.warn('snow_deploy_application is deprecated, redirecting to snow_deploy');
+                        return await this.handleDeprecatedApplicationDeploy(args);
                     case 'snow_deploy_update_set':
                         return await this.deployUpdateSet(args);
                     case 'snow_validate_deployment':
@@ -445,7 +495,11 @@ class ServiceNowDeploymentMCP {
                     case 'snow_flow_wizard':
                         return await this.flowWizard(args);
                     case 'snow_bulk_deploy':
-                        return await this.bulkDeploy(args);
+                        // Deprecated - redirect to unified deploy
+                        this.logger.warn('snow_bulk_deploy is deprecated, redirecting to snow_deploy with batch configuration');
+                        return await this.handleDeprecatedBulkDeploy(args);
+                    case 'snow_deploy':
+                        return await this.unifiedDeploy(args);
                     default:
                         throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
                 }
@@ -3605,6 +3659,670 @@ Use \`snow_preview_widget\` to see a detailed preview of the widget rendering.`,
                 return 'after';
         }
     }
+    /**
+     * UNIFIED DEPLOYMENT METHOD - Complete deployment workflow with resilient fallbacks
+     */
+    async unifiedDeploy(args) {
+        try {
+            this.logger.info('Starting unified deployment', args);
+            // CRITICAL: Check authentication FIRST before any deployment
+            const isAuthenticated = await this.oauth.isAuthenticated();
+            if (!isAuthenticated) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, 'Not authenticated. Run "snow-flow auth login" first.');
+            }
+            const { type, instruction, config, auto_update_set = true, fallback_strategy = 'manual_steps', permission_escalation = 'auto_request', deployment_context } = args;
+            // Step 1: Ensure Update Set session if requested
+            let updateSetSession = null;
+            if (auto_update_set) {
+                try {
+                    const ensureResponse = await this.ensureActiveUpdateSet(deployment_context || `${type} development`);
+                    updateSetSession = ensureResponse.session;
+                }
+                catch (error) {
+                    this.logger.warn('Failed to ensure Update Set, continuing without', error);
+                }
+            }
+            // Step 2: Prepare deployment configuration
+            let deploymentConfig;
+            if (instruction) {
+                // Natural language instruction - delegate to appropriate composer
+                deploymentConfig = await this.processNaturalLanguageInstruction(type, instruction);
+            }
+            else if (config) {
+                deploymentConfig = config;
+            }
+            else {
+                throw new Error('Either instruction or config must be provided');
+            }
+            // Step 3: Attempt deployment with cascade strategy
+            const deploymentStrategies = [
+                { scope: 'global', description: 'Global scope deployment' },
+                { scope: 'application', description: 'Application scope deployment' },
+                { scope: 'personal_dev', description: 'Personal developer instance' }
+            ];
+            let deploymentResult = null;
+            let lastError = null;
+            // Try each deployment strategy
+            for (const strategy of deploymentStrategies) {
+                try {
+                    this.logger.info(`Attempting ${strategy.description}`, { type, strategy: strategy.scope });
+                    deploymentResult = await this.attemptDirectDeployment(type, deploymentConfig, strategy.scope);
+                    if (deploymentResult.success) {
+                        // Track in Update Set if available
+                        if (updateSetSession && deploymentResult.sys_id) {
+                            await this.trackArtifactInUpdateSet(updateSetSession.update_set_id, {
+                                type,
+                                sys_id: deploymentResult.sys_id,
+                                name: deploymentResult.name || deploymentConfig.name || 'Unknown'
+                            });
+                        }
+                        return this.formatSuccessResponse(deploymentResult, strategy.scope, updateSetSession);
+                    }
+                }
+                catch (error) {
+                    lastError = error;
+                    this.logger.warn(`${strategy.description} failed`, error);
+                    // Handle permission errors with auto-escalation if enabled
+                    if (this.isPermissionError(error) && permission_escalation === 'auto_request') {
+                        try {
+                            const escalationResult = await this.requestPermissionEscalation(error, strategy.scope);
+                            if (escalationResult.granted) {
+                                // Use new scope if provided by escalation
+                                const effectiveScope = escalationResult.newScope || strategy.scope;
+                                this.logger.info('Retrying with escalated permissions', {
+                                    originalScope: strategy.scope,
+                                    newScope: effectiveScope
+                                });
+                                // Retry with escalated permissions and potentially new scope
+                                deploymentResult = await this.attemptDirectDeployment(type, deploymentConfig, effectiveScope);
+                                if (deploymentResult.success) {
+                                    return this.formatSuccessResponse(deploymentResult, effectiveScope, updateSetSession, 'escalated');
+                                }
+                            }
+                        }
+                        catch (escalationError) {
+                            this.logger.warn('Permission escalation failed', escalationError);
+                        }
+                    }
+                    continue; // Try next strategy
+                }
+            }
+            // Step 4: All direct deployment strategies failed - apply fallback
+            if (fallback_strategy === 'manual_steps') {
+                return await this.generateManualDeploymentSteps(type, deploymentConfig, lastError, updateSetSession);
+            }
+            else if (fallback_strategy === 'update_set_only') {
+                return await this.createUpdateSetPackage(type, deploymentConfig, updateSetSession);
+            }
+            else {
+                // No fallback - return failure
+                throw lastError || new Error('All deployment strategies failed');
+            }
+        }
+        catch (error) {
+            this.logger.error('Unified deployment failed completely', error);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ **Unified Deployment Failed**
+
+🚨 **Error**: ${error instanceof Error ? error.message : String(error)}
+
+🔧 **Next Steps:**
+1. Check your ServiceNow permissions
+2. Verify your authentication: \`snow_auth_diagnostics\`
+3. Try manual deployment: \`snow_create_${args.type}\` with specific configuration
+4. Contact your ServiceNow administrator for assistance
+
+💡 **Manual Alternative:**
+Use individual deployment tools like \`snow_deploy_${args.type}\` with manual configuration.`
+                    }]
+            };
+        }
+    }
+    /**
+     * Process natural language instruction into deployment configuration
+     */
+    async processNaturalLanguageInstruction(type, instruction) {
+        // For flows, delegate to flow composer
+        if (type === 'flow') {
+            // This would call the flow composer MCP, but for now return a basic structure
+            return {
+                name: this.extractNameFromInstruction(instruction),
+                description: instruction,
+                instruction: instruction
+            };
+        }
+        // For widgets, delegate to widget composer  
+        if (type === 'widget') {
+            return {
+                name: this.extractNameFromInstruction(instruction),
+                title: this.extractNameFromInstruction(instruction),
+                description: instruction,
+                instruction: instruction
+            };
+        }
+        // For other types, create basic configuration
+        return {
+            name: this.extractNameFromInstruction(instruction),
+            description: instruction
+        };
+    }
+    /**
+     * Extract a reasonable name from natural language instruction
+     */
+    extractNameFromInstruction(instruction) {
+        // Simple name extraction - could be enhanced with NLP
+        const words = instruction.toLowerCase().split(/\s+/);
+        let name = words.filter(word => word.length > 2 &&
+            !['the', 'and', 'for', 'with', 'that', 'will', 'can', 'should'].includes(word)).slice(0, 3).join('_');
+        return name || 'auto_generated_artifact';
+    }
+    /**
+     * Attempt direct deployment with specific scope
+     */
+    async attemptDirectDeployment(type, config, scope) {
+        // Add scope-specific configuration
+        const scopedConfig = { ...config, scope };
+        switch (type) {
+            case 'widget':
+                return await this.deployWidget(scopedConfig);
+            case 'flow':
+                return await this.deployFlow(scopedConfig);
+            case 'application':
+                return await this.deployApplication(scopedConfig);
+            default:
+                throw new Error(`Unsupported artifact type for unified deployment: ${type}`);
+        }
+    }
+    /**
+     * Check if error is permission-related
+     */
+    isPermissionError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return message.toLowerCase().includes('permission') ||
+            message.toLowerCase().includes('access') ||
+            message.includes('403') ||
+            message.toLowerCase().includes('role');
+    }
+    /**
+     * Request permission escalation
+     */
+    async requestPermissionEscalation(error, scope) {
+        this.logger.info('Attempting permission escalation', { error: error.message, scope });
+        // Determine required roles based on error message and scope
+        const requiredRoles = this.extractRequiredRoles(error, scope);
+        // Try multiple escalation strategies
+        const escalationStrategies = [
+            {
+                name: 'scoped_deployment',
+                description: 'Switch to scoped application deployment',
+                attempt: async () => {
+                    if (scope === 'global' && requiredRoles.includes('admin')) {
+                        // Fallback to scoped application
+                        this.logger.info('Attempting scoped deployment as fallback');
+                        return {
+                            granted: true,
+                            message: 'Switching to scoped application deployment (no global admin required)',
+                            newScope: 'x_custom_app'
+                        };
+                    }
+                    return { granted: false };
+                }
+            },
+            {
+                name: 'personal_scope',
+                description: 'Use personal developer scope',
+                attempt: async () => {
+                    if (scope !== 'personal') {
+                        this.logger.info('Attempting personal scope deployment');
+                        return {
+                            granted: true,
+                            message: 'Using personal developer scope for deployment',
+                            newScope: 'x_personal_dev'
+                        };
+                    }
+                    return { granted: false };
+                }
+            },
+            {
+                name: 'update_set_only',
+                description: 'Create in Update Set without direct deployment',
+                attempt: async () => {
+                    this.logger.info('Falling back to Update Set only creation');
+                    return {
+                        granted: true,
+                        message: 'Creating artifact definition in Update Set (manual import required)',
+                        newScope: 'update_set',
+                        requiresManualStep: true
+                    };
+                }
+            }
+        ];
+        // Try each escalation strategy
+        for (const strategy of escalationStrategies) {
+            try {
+                const result = await strategy.attempt();
+                if (result.granted) {
+                    return {
+                        granted: true,
+                        message: `${strategy.description}: ${result.message}`,
+                        ...result
+                    };
+                }
+            }
+            catch (err) {
+                this.logger.warn(`Escalation strategy ${strategy.name} failed`, err);
+            }
+        }
+        // If all strategies fail, provide detailed manual guidance
+        return {
+            granted: false,
+            message: this.generatePermissionGuidance(requiredRoles, scope, error)
+        };
+    }
+    /**
+     * Extract required roles from error message
+     */
+    extractRequiredRoles(error, scope) {
+        const message = error instanceof Error ? error.message : String(error);
+        const roles = [];
+        // Common role patterns in ServiceNow errors
+        if (message.includes('admin') || message.includes('administrator')) {
+            roles.push('admin');
+        }
+        if (message.includes('global') || scope === 'global') {
+            roles.push('global_admin');
+        }
+        if (message.includes('system_administrator')) {
+            roles.push('system_administrator');
+        }
+        if (message.includes('app_creator')) {
+            roles.push('app_creator');
+        }
+        return roles.length > 0 ? roles : ['admin']; // Default to admin if no specific role found
+    }
+    /**
+     * Generate detailed permission guidance
+     */
+    generatePermissionGuidance(roles, scope, error) {
+        const credentials = this.oauth.loadCredentials();
+        const instance = credentials?.then(c => c?.instance) || 'your-instance';
+        return `
+🔐 **Permission Escalation Required**
+
+**Required Roles**: ${roles.join(', ')}
+**Attempted Scope**: ${scope}
+
+**Option 1: Request Role Assignment**
+1. Navigate to: https://${instance}/nav_to.do?uri=sys_user.do?sys_id=<your_user_sys_id>
+2. Go to "Roles" related list
+3. Add roles: ${roles.join(', ')}
+
+**Option 2: Use Delegated Development**
+1. Create artifact in personal scope first
+2. Have admin promote to ${scope} scope
+3. Command: \`snow_deploy --scope personal\`
+
+**Option 3: Manual Import via Update Set**
+1. Export the generated Update Set XML
+2. Import as admin user
+3. Preview and commit the Update Set
+
+**Error Details**: ${error.message || error}`;
+    }
+    /**
+     * Format successful deployment response
+     */
+    formatSuccessResponse(result, scope, updateSetSession, method = 'direct') {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ **Unified Deployment Successful!**
+
+🎯 **Deployment Details:**
+- **Method**: ${method === 'escalated' ? 'Direct (with permission escalation)' : 'Direct deployment'}
+- **Scope**: ${scope}
+- **Artifact ID**: ${result.sys_id || 'N/A'}
+- **Name**: ${result.name || 'Unknown'}
+
+${updateSetSession ? `📋 **Update Set Tracking:**
+- **Update Set**: ${updateSetSession.name}
+- **Session ID**: ${updateSetSession.update_set_id}
+- **Artifacts**: ${(updateSetSession.artifacts?.length || 0) + 1} tracked
+
+⚡ **Ready for Testing**
+Your artifact has been deployed and is ready for testing.` : ''}
+
+🔗 **Next Steps:**
+1. Test the deployed artifact in ServiceNow
+2. ${updateSetSession ? 'Complete the Update Set when ready' : 'Create Update Set for deployment tracking'}
+3. Deploy to other environments when validated
+
+💡 **Success**: Unified deployment workflow completed successfully!`
+                }]
+        };
+    }
+    /**
+     * Generate manual deployment steps as fallback
+     */
+    async generateManualDeploymentSteps(type, config, error, updateSetSession) {
+        const credentials = await this.oauth.loadCredentials();
+        const instance = credentials?.instance || 'your-instance';
+        const steps = await this.generateTypeSpecificManualSteps(type, config, instance);
+        // Generate Update Set XML if available
+        let updateSetXml = '';
+        if (updateSetSession) {
+            try {
+                updateSetXml = await this.generateUpdateSetXML(type, config, updateSetSession);
+            }
+            catch (xmlError) {
+                this.logger.warn('Failed to generate Update Set XML', xmlError);
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `⚠️ **Automatic Deployment Failed - Manual Steps Generated**
+
+🚨 **Deployment Error**: ${error instanceof Error ? error.message : String(error)}
+
+${updateSetSession ? `📋 **Update Set Ready**: ${updateSetSession.name} (${updateSetSession.update_set_id})
+✅ Manual changes will be automatically tracked in this Update Set.
+🔗 **Update Set URL**: https://${instance}/sys_update_set.do?sys_id=${updateSetSession.update_set_id}` : ''}
+
+🔧 **Manual Deployment Steps with Direct URLs:**
+
+${steps}
+
+${updateSetXml ? `📄 **Update Set XML Generated**
+Copy this XML to import the artifact:
+\`\`\`xml
+${updateSetXml.substring(0, 500)}...
+\`\`\`
+💡 Full XML saved to: update_set_${updateSetSession.update_set_id}.xml` : ''}
+
+📊 **After Manual Deployment:**
+${updateSetSession ? '- Changes are automatically tracked in your active Update Set' : '- Consider creating an Update Set to track your changes'}
+- Test thoroughly in your development environment
+- Complete Update Set when ready for deployment
+
+💡 **Quick Actions:**
+- 🔧 Retry with different scope: \`snow_deploy --type ${type} --scope personal\`
+- 📋 Check permissions: \`snow_auth_diagnostics\`
+- 🚀 Use wizard mode: \`snow_${type}_wizard\``
+                }]
+        };
+    }
+    /**
+     * Generate type-specific manual steps
+     */
+    async generateTypeSpecificManualSteps(type, config, instance) {
+        switch (type) {
+            case 'widget':
+                return `1. **Open Service Portal Widgets**
+   🔗 URL: https://${instance}/nav_to.do?uri=%2F$sp_widget.do%3Fsys_id%3D-1%26sysparm_stack%3D$sp_widget_list.do
+   
+2. **Click "New" Button** (Top right of the page)
+   📸 Look for: Blue "New" button in the header
+   
+3. **Fill in Widget Details:**
+   - **Name**: ${config.name || 'your_widget_name'} (internal identifier)
+   - **ID**: ${config.id || config.name?.toLowerCase().replace(/\s+/g, '_') || 'widget_id'}
+   - **Title**: ${config.title || 'Your Widget Title'} (display name)
+   - **Description**: ${config.description || 'Widget created via Snow-Flow'}
+   
+4. **Add Widget Code:**
+   **HTML Template** tab:
+   \`\`\`html
+   ${config.template || '<div>Your HTML here</div>'}
+   \`\`\`
+   
+   **CSS - SCSS** tab:
+   \`\`\`css
+   ${config.css || '/* Your styles here */'}
+   \`\`\`
+   
+   **Client Script** tab:
+   \`\`\`javascript
+   ${config.client_script || 'function() {\n  var c = this;\n  // Your client code\n}'}
+   \`\`\`
+   
+   **Server Script** tab:
+   \`\`\`javascript
+   ${config.server_script || '(function() {\n  // Your server code\n})();'}
+   \`\`\`
+
+5. **Save the Widget**
+   - Click "Submit" or use Ctrl+S / Cmd+S
+   - Note the sys_id from the URL for tracking
+
+6. **Test Your Widget**
+   🔗 Test Page URL: https://${instance}/$sp.do?id=widget_editor&sys_id=YOUR_WIDGET_SYS_ID
+   
+7. **Add to Portal Page**
+   🔗 Page Designer: https://${instance}/nav_to.do?uri=%2F$sp_page.do`;
+            case 'flow':
+                return `1. **Open Flow Designer**
+   🔗 URL: https://${instance}/nav_to.do?uri=%2Fflow_designer.do
+   
+2. **Create New Flow**
+   - Click the "+" button or "New" in the top menu
+   - Select "Flow" (not Subflow or Action)
+   
+3. **Configure Flow Properties:**
+   - **Name**: ${config.name || 'approval_flow'}
+   - **Description**: ${config.description || 'Flow created via Snow-Flow'}
+   - **Application**: ${config.application || 'Global'}
+   - **Protection**: None (for development)
+   
+4. **Set Up Trigger** (Step 1 in Flow Designer):
+   - Click "Add a trigger"
+   - Select: "${config.trigger_type || 'Record Created'}"
+   - Table: ${config.table || 'Service Catalog Request [sc_request]'}
+   ${config.condition ? `- Condition: ${config.condition}` : ''}
+   
+5. **Add Flow Logic** (Example for approval flow):
+   a. **Add Approval Action**:
+      - Click "+" after trigger
+      - Search "Approval" 
+      - Select "Ask for Approval"
+      - Approver: ${config.approver || 'Manager of Requested for'}
+      
+   b. **Add Condition**:
+      - Click "+" → "Flow Logic" → "If"
+      - Condition: Approval State = Approved
+      
+   c. **Add Actions in "Then" branch**:
+      - Update Request: State = Approved
+      - Send Notification: To requester
+   
+6. **Save and Activate**
+   - Click "Save" (top right)
+   - Click "Activate" to make flow live
+   
+7. **Test Your Flow**
+   🔗 Test Execution: https://${instance}/nav_to.do?uri=%2Fsys_flow_context_list.do
+   - Create a test ${config.table || 'request'} record
+   - Monitor execution in Flow Designer`;
+            case 'application':
+                return `1. Navigate to System Applications > Applications in ServiceNow
+2. Click "New" to create a new application
+3. Set Name: ${config.name || 'Your Application Name'}
+4. Configure scope and permissions
+5. Add necessary tables, scripts, and other artifacts
+6. Test all functionality
+7. Publish when ready`;
+            default:
+                return `1. Navigate to the appropriate ServiceNow module
+2. Create the ${type} manually using the provided configuration
+3. Test thoroughly before deployment
+4. Document any changes made`;
+        }
+    }
+    /**
+     * Create Update Set package as fallback
+     */
+    async createUpdateSetPackage(type, config, updateSetSession) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `📦 **Update Set Package Created**
+
+${updateSetSession ? `📋 **Update Set**: ${updateSetSession.name}
+🆔 **Session ID**: ${updateSetSession.update_set_id}` : '⚠️ **No Update Set Session** - Create one manually before making changes'}
+
+📄 **Artifact Configuration Prepared:**
+- **Type**: ${type}
+- **Configuration**: Ready for manual deployment
+
+🔧 **Next Steps:**
+1. ${updateSetSession ? 'Update Set is already active' : 'Create or switch to an Update Set'}
+2. Manually create the ${type} in ServiceNow using the configuration
+3. All changes will be tracked in the Update Set
+4. Complete and deploy the Update Set to other environments
+
+💡 **Benefit**: Even though automatic deployment failed, you have a complete deployment package ready.`
+                }]
+        };
+    }
+    /**
+     * Track artifact in Update Set
+     */
+    async trackArtifactInUpdateSet(updateSetId, artifact) {
+        try {
+            // This would call the update set MCP to track the artifact
+            this.logger.info('Tracking artifact in Update Set', { updateSetId, artifact });
+            // For now, just log - in real implementation would call the MCP
+        }
+        catch (error) {
+            this.logger.warn('Failed to track artifact in Update Set', error);
+        }
+    }
+    /**
+     * Ensure active Update Set session
+     */
+    async ensureActiveUpdateSet(context) {
+        // This would call the update set MCP to ensure active session
+        // For now, return a mock session
+        return {
+            session: {
+                update_set_id: 'mock_update_set_id',
+                name: `Auto-${context}`,
+                artifacts: []
+            }
+        };
+    }
+    /**
+     * DEPRECATION HANDLERS - Redirect old tools to new unified system
+     */
+    async handleDeprecatedWidgetDeploy(args) {
+        const deprecationWarning = `⚠️ **DEPRECATED TOOL USED**
+
+🚨 **snow_deploy_widget is deprecated** - Use \`snow_deploy\` instead
+
+📋 **Automatic Redirect**: Converting to unified deployment...
+
+`;
+        // Convert old widget args to unified deploy format
+        const unifiedArgs = {
+            type: 'widget',
+            config: args,
+            auto_update_set: true,
+            fallback_strategy: 'manual_steps'
+        };
+        const result = await this.unifiedDeploy(unifiedArgs);
+        // Prepend deprecation warning to the result
+        if (result.content && result.content[0]) {
+            result.content[0].text = deprecationWarning + result.content[0].text;
+        }
+        return result;
+    }
+    async handleDeprecatedFlowDeploy(args) {
+        const deprecationWarning = `⚠️ **DEPRECATED TOOL USED**
+
+🚨 **snow_deploy_flow is deprecated** - Use \`snow_deploy\` instead
+
+📋 **Automatic Redirect**: Converting to unified deployment...
+
+`;
+        // Convert old flow args to unified deploy format
+        const unifiedArgs = {
+            type: 'flow',
+            config: args,
+            auto_update_set: true,
+            fallback_strategy: 'manual_steps'
+        };
+        const result = await this.unifiedDeploy(unifiedArgs);
+        // Prepend deprecation warning to the result
+        if (result.content && result.content[0]) {
+            result.content[0].text = deprecationWarning + result.content[0].text;
+        }
+        return result;
+    }
+    async handleDeprecatedApplicationDeploy(args) {
+        const deprecationWarning = `⚠️ **DEPRECATED TOOL USED**
+
+🚨 **snow_deploy_application is deprecated** - Use \`snow_deploy\` instead
+
+📋 **Automatic Redirect**: Converting to unified deployment...
+
+`;
+        // Convert old application args to unified deploy format
+        const unifiedArgs = {
+            type: 'application',
+            config: args,
+            auto_update_set: true,
+            fallback_strategy: 'manual_steps'
+        };
+        const result = await this.unifiedDeploy(unifiedArgs);
+        // Prepend deprecation warning to the result
+        if (result.content && result.content[0]) {
+            result.content[0].text = deprecationWarning + result.content[0].text;
+        }
+        return result;
+    }
+    async handleDeprecatedBulkDeploy(args) {
+        const deprecationWarning = `⚠️ **DEPRECATED TOOL USED**
+
+🚨 **snow_bulk_deploy is deprecated** - Use \`snow_deploy\` with batch configuration instead
+
+📋 **Automatic Redirect**: Converting to unified deployment...
+
+💡 **New Usage**: Use \`snow_deploy\` for single artifacts or implement batch logic with multiple \`snow_deploy\` calls
+
+`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${deprecationWarning}
+
+❌ **Bulk Deploy No Longer Supported in Unified System**
+
+🔧 **Alternative Solutions:**
+
+**Option 1: Single Artifact Deployment**
+\`\`\`
+snow_deploy({
+  type: 'widget',
+  config: { /* your widget config */ }
+})
+\`\`\`
+
+**Option 2: Multiple Sequential Deployments**
+Deploy each artifact individually using \`snow_deploy\` - the unified system automatically manages Update Sets across all deployments.
+
+**Option 3: Use Existing Bulk Deploy (Legacy)**
+The original \`snow_bulk_deploy\` functionality is still available but deprecated. Consider migrating to the simplified \`snow_deploy\` approach.
+
+📊 **Benefits of New Approach:**
+- Automatic Update Set management
+- Better error handling per artifact
+- Clearer deployment tracking
+- Resilient fallback strategies`
+                }]
+        };
+    }
     async start() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);