snow-flow 3.3.2 → 3.3.3

package/README.md

@@ -97,7 +97,7 @@ Snow-Flow provides 180+ tools across 17 specialized MCP servers:
 | Server | Tools | Primary Focus |
 |--------|-------|---------------|
 | servicenow-operations | 15 | CRUD operations, data management |
-| servicenow-deployment | 20 | Widget, portal, and application deployment |
+| servicenow-deployment | 21 | Widget, portal, and application deployment (create & update) |
 | servicenow-platform-development | 12 | Table creation, field management |
 | servicenow-machine-learning | 15 | Neural networks, predictions, anomaly detection |
 | servicenow-reporting-analytics | 18 | Dashboards, reports, KPIs |
@@ -288,7 +288,7 @@ snow_query_table({
 ```
 
 ### Development Tools
-- Widget creation and deployment
+- Widget creation and deployment (snow_deploy for new, snow_update for existing)
 - Business rule development
 - Script include management
 - Flow Designer automation

package/dist/dynamic-version.js

@@ -36,7 +36,7 @@ function getDynamicVersion() {
         console.warn('Warning: Could not read version from package.json:', error);
     }
     // Fallback to hardcoded version
-    return '3.3.2';
+    return '3.3.3';
 }
 // Export a constant that uses the dynamic version
 exports.VERSION = getDynamicVersion();

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

@@ -234,9 +234,46 @@ class ServiceNowDeploymentMCP {
                         required: ['name', 'artifacts'],
                     },
                 },
+                {
+                    name: 'snow_update',
+                    description: 'Updates existing ServiceNow artifacts (widgets, applications, etc.). Finds artifact by name or sys_id and modifies it. Use snow_deploy for creating new artifacts.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            type: {
+                                type: 'string',
+                                enum: ['widget', 'application', 'business_rule', 'script_include', 'ui_page'],
+                                description: 'Type of artifact to update'
+                            },
+                            identifier: {
+                                type: 'string',
+                                description: 'sys_id or name of existing artifact to update'
+                            },
+                            config: {
+                                type: 'object',
+                                description: 'New configuration/content for the artifact'
+                            },
+                            instruction: {
+                                type: 'string',
+                                description: 'Natural language description of changes to make'
+                            },
+                            create_if_not_exists: {
+                                type: 'boolean',
+                                default: false,
+                                description: 'Create artifact if it does not exist'
+                            },
+                            auto_update_set: {
+                                type: 'boolean',
+                                default: true,
+                                description: 'Automatically manage update set'
+                            }
+                        },
+                        required: ['type', 'identifier']
+                    }
+                },
                 {
                     name: 'snow_deploy',
-                    description: 'Universal deployment tool for all ServiceNow artifacts. Features automatic update set management, permission escalation, retry logic, and comprehensive error recovery. Primary deployment method for v3.0.0+',
+                    description: 'Universal deployment tool for creating NEW ServiceNow artifacts. For updating existing artifacts, use snow_update. Features automatic update set management, permission escalation, retry logic, and comprehensive error recovery.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -313,6 +350,8 @@ class ServiceNowDeploymentMCP {
                         return await this.createSolutionPackage(args);
                     case 'snow_deploy':
                         return await this.unifiedDeploy(args);
+                    case 'snow_update':
+                        return await this.updateArtifact(args);
                     default:
                         throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
                 }
@@ -8092,6 +8131,260 @@ ${updateSetSession ? `📋 **Update Set**: ${updateSetSession.name}
             throw new Error(`Update Set session required for deployment. Error: ${error.message}`);
         }
     }
+    /**
+     * Update existing ServiceNow artifact
+     */
+    async updateArtifact(args) {
+        try {
+            this.logger.info('Starting artifact update', args);
+            // Check authentication first
+            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, identifier, config, instruction, create_if_not_exists = false, auto_update_set = true } = args;
+            // Step 1: Ensure Update Set if requested
+            let updateSetSession = null;
+            if (auto_update_set) {
+                try {
+                    const ensureResponse = await this.ensureActiveUpdateSet(`${type} update: ${identifier}`);
+                    updateSetSession = ensureResponse.session;
+                }
+                catch (error) {
+                    this.logger.warn('Failed to ensure Update Set, continuing without', error);
+                }
+            }
+            // Step 2: Determine table name
+            let tableName;
+            switch (type) {
+                case 'widget':
+                    tableName = 'sp_widget';
+                    break;
+                case 'application':
+                    tableName = 'sys_app';
+                    break;
+                case 'business_rule':
+                    tableName = 'sys_script';
+                    break;
+                case 'script_include':
+                    tableName = 'sys_script_include';
+                    break;
+                case 'ui_page':
+                    tableName = 'sys_ui_page';
+                    break;
+                default:
+                    throw new Error(`Unsupported artifact type: ${type}`);
+            }
+            // Step 3: Find existing artifact
+            let existingArtifact = null;
+            let searchQuery = '';
+            // Check if identifier is a sys_id (32 char hex) or a name
+            const isSysId = /^[a-f0-9]{32}$/.test(identifier);
+            if (isSysId) {
+                searchQuery = `sys_id=${identifier}`;
+            }
+            else {
+                searchQuery = `name=${identifier}`;
+            }
+            this.logger.info(`Searching for ${type} with query: ${searchQuery}`);
+            try {
+                const searchResponse = await this.client.searchRecords(tableName, searchQuery, 1);
+                if (searchResponse?.data?.result?.length > 0) {
+                    existingArtifact = searchResponse.data.result[0];
+                    this.logger.info(`Found existing ${type}: ${existingArtifact.sys_id}`);
+                }
+            }
+            catch (searchError) {
+                this.logger.error(`Failed to search for ${type}:`, searchError);
+            }
+            // Step 4: Handle artifact not found
+            if (!existingArtifact) {
+                if (create_if_not_exists) {
+                    this.logger.info(`${type} not found, creating new one as requested`);
+                    // Delegate to snow_deploy for creation
+                    return await this.unifiedDeploy({
+                        type,
+                        config,
+                        instruction,
+                        auto_update_set
+                    });
+                }
+                else {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `❌ ${type} not found: "${identifier}"
+
+🔍 **Search Details:**
+- Table: ${tableName}
+- Search Query: ${searchQuery}
+- Results: 0
+
+💡 **Suggestions:**
+1. Check the ${isSysId ? 'sys_id' : 'name'} is correct
+2. Verify you have read permissions for ${tableName}
+3. Use exact ${isSysId ? 'sys_id format (32 char hex)' : 'name (case sensitive)'}
+4. Add create_if_not_exists: true to create if missing
+
+🔧 **Alternative Commands:**
+- List existing: \`snow_query_table({ table: "${tableName}", limit: 10 })\`
+- Create new: \`snow_deploy({ type: "${type}", ... })\`
+- Find by name: \`snow_update({ type: "${type}", identifier: "exact_name" })\``
+                            }]
+                    };
+                }
+            }
+            // Step 5: Process update configuration
+            let updateData = {};
+            if (instruction) {
+                // Natural language instruction - convert to specific updates
+                updateData = await this.processUpdateInstruction(type, instruction, existingArtifact);
+            }
+            else if (config) {
+                updateData = config;
+            }
+            else {
+                throw new Error('Either instruction or config must be provided for update');
+            }
+            // Step 6: Perform the update
+            this.logger.info(`Updating ${type} ${existingArtifact.sys_id}`, updateData);
+            const updateResponse = await this.client.updateRecord(tableName, existingArtifact.sys_id, updateData);
+            if (!updateResponse?.success) {
+                throw new Error(`Failed to update ${type}: ${updateResponse?.error || 'Unknown error'}`);
+            }
+            // Step 7: Track the update
+            if (updateSetSession) {
+                artifact_tracker_js_1.artifactTracker.trackArtifact({
+                    type: type,
+                    name: existingArtifact.name,
+                    sys_id: existingArtifact.sys_id,
+                    operation: 'update',
+                    table: tableName,
+                    update_set_id: updateSetSession.update_set_id
+                });
+            }
+            // Step 8: Return success response
+            const updatedFields = Object.keys(updateData);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ ${type} updated successfully!
+
+📝 **Updated Artifact:**
+- Name: ${existingArtifact.name}
+- sys_id: ${existingArtifact.sys_id}
+- Table: ${tableName}
+
+🔧 **Fields Updated:**
+${updatedFields.map(field => `- ${field}`).join('\n')}
+
+${updateSetSession ? `📦 **Update Set:**
+- Name: ${updateSetSession.name}
+- sys_id: ${updateSetSession.update_set_id}
+- Ready for promotion to higher environments` : '🔄 Changes made outside Update Set - track manually'}
+
+💡 **Next Steps:**
+1. Test the updated ${type} in your environment
+2. ${updateSetSession ? 'Preview and commit Update Set when ready' : 'Create Update Set to track changes'}
+3. Promote to production after validation
+
+🔗 **ServiceNow Links:**
+- View artifact: /nav_to.do?uri=${tableName}.do?sys_id=${existingArtifact.sys_id}
+${updateSetSession ? `- View Update Set: /nav_to.do?uri=sys_update_set.do?sys_id=${updateSetSession.update_set_id}` : ''}`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Artifact update failed:', error);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Failed to update ${args.type}: ${error.message}
+
+🔍 **Troubleshooting:**
+1. Verify the artifact exists: \`snow_query_table({ table: "${this.getTableName(args.type)}", query: "name=${args.identifier}" })\`
+2. Check permissions for ${this.getTableName(args.type)} table
+3. Ensure Update Set is active (if required)
+4. Try with create_if_not_exists: true if artifact might not exist
+
+💡 **Alternative:**
+Use \`snow_deploy\` to create a new ${args.type} instead.`
+                    }]
+            };
+        }
+    }
+    /**
+     * Process natural language instruction for updates
+     */
+    async processUpdateInstruction(type, instruction, existingArtifact) {
+        const updateData = {};
+        // Simple natural language processing for common update patterns
+        const lowerInstruction = instruction.toLowerCase();
+        if (type === 'widget') {
+            // Widget-specific updates
+            if (lowerInstruction.includes('html') || lowerInstruction.includes('template')) {
+                if (lowerInstruction.includes('add') || lowerInstruction.includes('update')) {
+                    // Extract HTML content if provided
+                    const htmlMatch = instruction.match(/```html\s*\n([\s\S]*?)\n```/);
+                    if (htmlMatch) {
+                        updateData.template = htmlMatch[1];
+                    }
+                }
+            }
+            if (lowerInstruction.includes('css') || lowerInstruction.includes('style')) {
+                const cssMatch = instruction.match(/```css\s*\n([\s\S]*?)\n```/);
+                if (cssMatch) {
+                    updateData.css = cssMatch[1];
+                }
+            }
+            if (lowerInstruction.includes('script') || lowerInstruction.includes('javascript')) {
+                const jsMatch = instruction.match(/```javascript\s*\n([\s\S]*?)\n```/);
+                if (jsMatch) {
+                    updateData.script = jsMatch[1];
+                }
+            }
+            if (lowerInstruction.includes('server') || lowerInstruction.includes('server script')) {
+                const serverMatch = instruction.match(/```javascript\s*\n([\s\S]*?)\n```/);
+                if (serverMatch) {
+                    updateData.script = serverMatch[1];
+                }
+            }
+            // Update description if mentioned
+            if (lowerInstruction.includes('description')) {
+                const descMatch = instruction.match(/description:?\s*["']([^"']+)["']/i);
+                if (descMatch) {
+                    updateData.short_description = descMatch[1];
+                }
+            }
+        }
+        // If no specific patterns matched, add as general update
+        if (Object.keys(updateData).length === 0) {
+            // For now, return instruction for manual processing
+            updateData._instruction = instruction;
+            // You could add more sophisticated NLP processing here
+            // or integrate with AI services to interpret the instruction
+        }
+        return updateData;
+    }
+    /**
+     * Get table name for artifact type
+     */
+    getTableName(type) {
+        switch (type) {
+            case 'widget':
+                return 'sp_widget';
+            case 'application':
+                return 'sys_app';
+            case 'business_rule':
+                return 'sys_script';
+            case 'script_include':
+                return 'sys_script_include';
+            case 'ui_page':
+                return 'sys_ui_page';
+            default:
+                return 'sys_metadata';
+        }
+    }
     async start() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.3.2",
-  "description": "Snow-Flow v3.3.2: ServiceNow development platform with 180+ MCP tools. Enhanced MCP servers with real-time progress indicators, per-operation token tracking (tokens reset per call), and comprehensive operation logging. Supports ATF Testing, Knowledge Management, Service Catalog, Change Management, Virtual Agent, Performance Analytics, Flow Designer, Agent Workspace, Mobile, CMDB/Discovery, Event Management, HR Service Delivery, Customer Service Management, and DevOps integration. All tools use official ServiceNow REST APIs across 17 specialized MCP servers with full visibility into API operations.",
+  "version": "3.3.3",
+  "description": "Snow-Flow v3.3.3: ServiceNow development platform with 180+ MCP tools. NEW: snow_update tool for updating existing artifacts (vs snow_deploy for new). Enhanced MCP servers with real-time progress indicators, per-operation token tracking (tokens reset per call), and comprehensive operation logging. Supports ATF Testing, Knowledge Management, Service Catalog, Change Management, Virtual Agent, Performance Analytics, Flow Designer, Agent Workspace, Mobile, CMDB/Discovery, Event Management, HR Service Delivery, Customer Service Management, and DevOps integration. All tools use official ServiceNow REST APIs across 17 specialized MCP servers with full visibility into API operations.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {