snow-flow 4.5.21 → 4.5.23

package/CLAUDE.md

@@ -524,20 +524,25 @@ Snow-Flow includes 18 specialized MCP servers, each providing comprehensive Serv
 - Property validation
 
 ### 7. ServiceNow Update Set Server
-**Purpose:** Change management and deployment
+**Purpose:** Change management and deployment with automatic user synchronization
 
 **Key Tools:**
 - `snow_create_update_set` - Create new update sets
-- `snow_switch_update_set` - Switch active update set
+- `snow_ensure_active_update_set` - Ensure active Update Set (auto-syncs current)
+- `snow_sync_current_update_set` - **NEW:** Sync user's current Update Set with Snow-Flow
 - `snow_complete_update_set` - Mark as complete
 - `snow_preview_update_set` - Preview changes
 - `snow_export_update_set` - Export as XML
 
+**🆕 AUTO-SYNC FEATURE:**
+Snow-Flow now automatically sets its Update Set as the user's current Update Set in ServiceNow. This prevents confusion where Snow-Flow works in one Update Set while the user sees a different current Update Set.
+
 **Features:**
-- Full update set lifecycle
-- Change tracking
-- XML export/import
-- Conflict detection
+- **Automatic current Update Set synchronization** - user and Snow-Flow always in same Update Set
+- Full update set lifecycle management
+- Change tracking and artifact management
+- XML export/import capabilities
+- Conflict detection and resolution
 
 ### 8. ServiceNow Development Assistant Server
 **Purpose:** Code generation and best practices

package/dist/mcp/servicenow-flow-workspace-mobile-mcp.js

@@ -1281,19 +1281,34 @@ ${executionList}
                     suggestion: 'Install Agent Workspace plugin: System Applications → All Available Applications → Search for "Agent Workspace"'
                 };
             }
+            // Fix from user feedback: Add ALL required fields for workspace creation
+            const workspaceUrl = this.generateWorkspaceUrl(args.name);
             const workspaceData = {
                 name: args.name,
                 description: args.description || '',
+                active: true,
+                // CRITICAL: Add missing required fields
+                workspace_url: workspaceUrl,
+                navigation_type: 'tab',
+                search_enabled: true,
+                notifications_enabled: true,
+                user_preference_controls_enabled: true,
+                // Add default colors for branding
+                primary_color: '#1F8476',
+                brand_color: '#2FC2B0',
+                // These will be updated after search config creation
+                global_search: '',
+                global_search_data: '',
+                // Optional fields with defaults
                 tables: args.tables ? args.tables.join(',') : '',
                 home_page: args.home_page || '',
                 theme: args.theme || 'default',
-                roles: args.roles ? args.roles.join(',') : '',
-                active: true
+                roles: args.roles ? args.roles.join(',') : ''
             };
             this.logger.trackAPICall('CREATE', 'sys_aw_master_config', 1);
             const response = await this.client.createRecord('sys_aw_master_config', workspaceData);
             if (!response.success) {
-                // Provide specific error guidance
+                // Enhanced error handling with required fields info
                 if (response.error?.includes('403') || response.error?.includes('Forbidden')) {
                     return {
                         success: false,
@@ -1304,12 +1319,52 @@ ${executionList}
                 if (response.error?.includes('400') || response.error?.includes('Bad Request')) {
                     return {
                         success: false,
-                        error: 'Invalid workspace configuration. Agent Workspace may not be properly configured in this instance.',
-                        suggestion: 'Verify Agent Workspace is enabled and configured. Check System Properties > Agent Workspace settings.'
+                        error: 'Invalid workspace configuration. Missing required fields detected.',
+                        suggestion: 'Verify all required fields: workspace_url, navigation_type, search settings.',
+                        remediation: 'Check ServiceNow Agent Workspace documentation for required field specifications'
                     };
                 }
                 throw new Error(`Failed to create workspace: ${response.error}`);
             }
+            const workspaceId = response.data.sys_id;
+            // Fix from user feedback: Create global search config and update workspace
+            try {
+                const searchConfig = await this.client.createRecord('sys_aw_global_search_config', {
+                    name: `${args.name} Search`,
+                    workspace: workspaceId,
+                    active: true
+                });
+                if (searchConfig.success && searchConfig.data.sys_id) {
+                    // Update workspace with search config references
+                    await this.client.updateRecord('sys_aw_master_config', workspaceId, {
+                        global_search: searchConfig.data.sys_id,
+                        global_search_data: searchConfig.data.sys_id
+                    });
+                }
+            }
+            catch (searchError) {
+                this.logger.warn('Could not create search config, workspace created without search:', searchError);
+            }
+            // Fix from user feedback: Create tabs for each table automatically
+            if (args.tables && args.tables.length > 0) {
+                for (let i = 0; i < args.tables.length; i++) {
+                    const table = args.tables[i];
+                    const tabLabel = table.replace(/_/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase());
+                    try {
+                        await this.client.createRecord('sys_aw_tab', {
+                            workspace: workspaceId,
+                            table: table,
+                            label: tabLabel,
+                            name: `${table}_tab`,
+                            order: (i + 1) * 100,
+                            active: true
+                        });
+                    }
+                    catch (tabError) {
+                        this.logger.warn(`Could not create tab for table ${table}:`, tabError);
+                    }
+                }
+            }
             return {
                 content: [{
                         type: 'text',
@@ -2871,6 +2926,37 @@ ${configList}${layoutsText}${offlineText}
             throw error;
         }
     }
+    /**
+     * Generate valid workspace URL from name (fix from user feedback)
+     */
+    generateWorkspaceUrl(name) {
+        return name
+            .toLowerCase()
+            .trim()
+            .replace(/\s+/g, '-') // Spaces -> hyphens
+            .replace(/[^a-z0-9-]/g, '') // Remove special characters
+            .replace(/--+/g, '-') // Multiple hyphens -> single
+            .replace(/^-|-$/g, '') // Trim leading/trailing hyphens
+            .substring(0, 80); // Max 80 chars (ServiceNow field limit)
+    }
+    /**
+     * Validate workspace configuration (fix from user feedback)
+     */
+    validateWorkspaceConfig(config) {
+        const errors = [];
+        // Check required fields
+        if (!config.name)
+            errors.push('name is required');
+        if (!config.workspace_url)
+            errors.push('workspace_url is required');
+        if (!config.navigation_type)
+            errors.push('navigation_type is required');
+        // Validate workspace_url format
+        if (config.workspace_url && !/^[a-z0-9-]+$/.test(config.workspace_url)) {
+            errors.push('workspace_url must contain only lowercase letters, numbers and hyphens');
+        }
+        return errors;
+    }
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);

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

@@ -263,6 +263,9 @@ class ServiceNowUpdateSetMCP {
                     case 'snow_ensure_active_update_set':
                         result = await this.ensureActiveUpdateSet(args);
                         break;
+                    case 'snow_sync_current_update_set':
+                        result = await this.syncCurrentUpdateSet(args);
+                        break;
                     default:
                         throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
                 }
@@ -663,20 +666,19 @@ ${changes.length > 20 ? `\n... and ${changes.length - 20} more changes` : ''}
             this.logger.info('Ensuring active Update Set session', args);
             // Check if we already have an active session
             if (this.currentSession?.state === 'in_progress') {
+                // Also sync current Update Set if requested
+                if (args.set_as_current !== false) {
+                    await this.syncCurrentUpdateSet({ force_switch: true });
+                }
                 return {
-                    content: [{
-                            type: 'text',
-                            text: `✅ **Active Update Set Session Found**
-
-📋 **Current Session:**
-- **Name**: ${this.currentSession.name}
-- **ID**: ${this.currentSession.update_set_id}
-- **Created**: ${new Date(this.currentSession.created_at).toLocaleString()}
-- **Artifacts**: ${this.currentSession.artifacts?.length || 0} tracked
-
-⚡ **Ready for Deployment**
-All subsequent changes will be tracked in this Update Set.`
-                        }]
+                    success: true,
+                    message: 'Active Update Set session found and synchronized',
+                    update_set: {
+                        name: this.currentSession.name,
+                        sys_id: this.currentSession.update_set_id,
+                        artifacts_count: this.currentSession.artifacts?.length || 0
+                    },
+                    synchronized: args.set_as_current !== false
                 };
             }
             // Auto-create if requested (default: true)
@@ -737,6 +739,86 @@ snow_update_set_create({
             .map(([type, count]) => `- ${type}: ${count}`)
             .join('\n');
     }
+    /**
+     * NEW: Synchronize user's current Update Set with Snow-Flow's active Update Set
+     */
+    async syncCurrentUpdateSet(args) {
+        try {
+            this.logger.info('Synchronizing user current Update Set with Snow-Flow session...');
+            if (!this.currentSession) {
+                return {
+                    success: false,
+                    error: 'No active Snow-Flow Update Set session found.',
+                    suggestion: 'Run snow_ensure_active_update_set first to create or activate an Update Set.'
+                };
+            }
+            // Set Snow-Flow Update Set as current for user via script
+            const syncScript = `
+        // Synchronize user's current Update Set with Snow-Flow session
+        var updateSetId = '${this.currentSession.update_set_id}';
+        var currentUser = gs.getUserID();
+        
+        // Get current Update Set info
+        var updateSet = new GlideRecord('sys_update_set');
+        if (updateSet.get(updateSetId)) {
+          gs.info('Snow-Flow Update Set found: ' + updateSet.name);
+          
+          // Set as current for user via session variable
+          gs.getSession().putProperty('update_set', updateSetId);
+          gs.info('Set as current Update Set for user: ' + updateSet.name);
+          
+          // Also try to set via user preference
+          var pref = new GlideRecord('sys_user_preference');
+          pref.addQuery('user', currentUser);
+          pref.addQuery('name', 'update_set.current');
+          pref.query();
+          
+          if (pref.next()) {
+            pref.value = updateSetId;
+            pref.update();
+            gs.info('Updated user preference for current Update Set');
+          } else {
+            var newPref = new GlideRecord('sys_user_preference');
+            newPref.initialize();
+            newPref.user = currentUser;
+            newPref.name = 'update_set.current';
+            newPref.value = updateSetId;
+            newPref.insert();
+            gs.info('Created user preference for current Update Set');
+          }
+          
+          gs.info('SYNC COMPLETE: User current Update Set = Snow-Flow session Update Set');
+        } else {
+          gs.error('Snow-Flow Update Set not found: ' + updateSetId);
+        }
+      `;
+            const scriptResponse = await this.client.executeScript(syncScript);
+            if (!scriptResponse.success) {
+                return {
+                    success: false,
+                    error: 'Failed to synchronize current Update Set',
+                    suggestion: 'Check ServiceNow connection and Update Set permissions',
+                    update_set_id: this.currentSession.update_set_id
+                };
+            }
+            return {
+                success: true,
+                message: `Current Update Set synchronized with Snow-Flow session`,
+                update_set_name: this.currentSession.name,
+                update_set_id: this.currentSession.update_set_id,
+                sync_method: 'session_variable_and_user_preference',
+                sync_status: 'completed'
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to sync current Update Set:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                suggestion: 'Check ServiceNow connection and permissions'
+            };
+        }
+    }
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "4.5.21",
+  "version": "4.5.23",
   "description": "Conversational ServiceNow development platform using Claude Code. Multi-agent orchestration with 20+ MCP servers providing 200+ ServiceNow tools for comprehensive platform development.",
   "main": "dist/index.js",
   "type": "commonjs",