snow-flow 3.5.15 → 3.5.17

package/dist/utils/artifact-local-sync.d.ts

@@ -86,19 +86,13 @@ export declare class ArtifactLocalSync {
      */
     private validateES5;
     /**
-     * Strip headers/footers we added - FIXED to use actual fieldMapping wrappers
+     * AGGRESSIVE STRIP FUNCTION: Remove ALL possible Snow-Flow wrapper variations
+     * FIXED: Handles multiple/nested wrappers and all patterns
      */
     private stripAddedWrappers;
     /**
-     * Create regex pattern from wrapper text, handling placeholders
-     */
-    private escapeRegexAndCreatePattern;
-    /**
-     * Fallback: Strip generic comments when no fieldMapping available
-     */
-    private stripGenericComments;
-    /**
-     * INTELLIGENT WRAPPER DETECTION: Check if content actually needs wrappers
+     * CONSERVATIVE WRAPPER DETECTION: Only add wrappers if content is truly minimal
+     * FIXED: Now properly detects ALL types of existing wrappers/comments
      */
     private needsWrappers;
     /**
@@ -115,6 +109,7 @@ export declare class ArtifactLocalSync {
     getSyncStatus(sys_id: string): string;
     /**
      * Pull any supported artifact type by detecting table from sys_id
+     * ENHANCED: Better error logging and more robust detection
      */
     pullArtifactBySysId(sys_id: string): Promise<LocalArtifact>;
     /**

package/dist/utils/artifact-local-sync.js

@@ -127,7 +127,8 @@ class ArtifactLocalSync {
             throw new Error(`Unsupported artifact type: ${tableName}. Supported types: ${Object.keys(artifact_registry_1.ARTIFACT_REGISTRY).join(', ')}`);
         }
         console.log(`\n🔄 Pulling ${config.displayName} (${sys_id}) to local files...`);
-        console.log(`📋 Snow-Flow v3.5.15 - Intelligent Wrapper System Active`);
+        console.log(`📋 Snow-Flow v3.5.16 - ULTRA-CONSERVATIVE Wrapper System (No More Duplicates!)`);
+        console.log(`⚠️  CRITICAL FIX: Aggressive strip & minimal wrapper addition only`);
         // Get timeout configuration
         const timeoutConfig = (0, mcp_timeout_config_js_1.getMCPTimeoutConfig)();
         // Use smart fetcher for known types, otherwise direct query
@@ -187,16 +188,21 @@ class ArtifactLocalSync {
                 .replace('{name}', sanitizedName)
                 .replace('{api_name}', artifactData.api_name || sanitizedName)
                 .replace('{short_description}', artifactData.short_description || sanitizedName);
-            // INTELLIGENT WRAPPER SYSTEM: Only add wrappers if actually needed
+            // ULTRA-CONSERVATIVE WRAPPER SYSTEM: When in doubt, don't add wrappers
             let header = '';
             let footer = '';
-            if (mapping.wrapperHeader && mapping.wrapperFooter && this.needsWrappers(processedContent, mapping)) {
-                header = this.replacePlaceholders(mapping.wrapperHeader, artifactData);
-                footer = this.replacePlaceholders(mapping.wrapperFooter, artifactData);
-                console.log(`   🔧 Adding wrappers for ${filename} (content needs them)`);
-            }
-            else if (mapping.wrapperHeader && mapping.wrapperFooter) {
-                console.log(`   ✅ Skipping wrappers for ${filename} (content is already wrapped)`);
+            // FAILSAFE: Only add wrappers if we're absolutely certain it's safe
+            if (mapping.wrapperHeader && mapping.wrapperFooter) {
+                const shouldAddWrappers = this.needsWrappers(processedContent, mapping);
+                if (shouldAddWrappers && processedContent.trim().length < 50) {
+                    // EXTRA SAFETY: Only for very short content
+                    header = this.replacePlaceholders(mapping.wrapperHeader, artifactData);
+                    footer = this.replacePlaceholders(mapping.wrapperFooter, artifactData);
+                    console.log(`   🔧 Adding wrappers for ${filename} (content is minimal: ${processedContent.trim().length} chars)`);
+                }
+                else {
+                    console.log(`   ✅ Skipping wrappers for ${filename} (conservative approach)`);
+                }
             }
             const file = this.createLocalFile(artifactPath, `${filename}.${mapping.fileExtension}`, processedContent, mapping.serviceNowField, mapping.fileExtension, header, footer);
             file.fieldMapping = mapping;
@@ -580,104 +586,97 @@ snow-flow sync status ${widget.sys_id}
         return issues;
     }
     /**
-     * Strip headers/footers we added - FIXED to use actual fieldMapping wrappers
+     * AGGRESSIVE STRIP FUNCTION: Remove ALL possible Snow-Flow wrapper variations
+     * FIXED: Handles multiple/nested wrappers and all patterns
      */
     stripAddedWrappers(content, type, fieldMapping) {
-        if (!fieldMapping || !fieldMapping.wrapperHeader || !fieldMapping.wrapperFooter) {
-            // No wrappers defined, just remove generic comments
-            return this.stripGenericComments(content, type);
-        }
-        let cleaned = content;
-        // Get the actual wrappers that were added (without placeholders)
-        const header = fieldMapping.wrapperHeader;
-        const footer = fieldMapping.wrapperFooter;
-        // CRITICAL FIX: Use the EXACT wrappers from fieldMapping
-        if (header && footer) {
-            // Create regex patterns from the actual wrappers
-            const headerPattern = this.escapeRegexAndCreatePattern(header);
-            const footerPattern = this.escapeRegexAndCreatePattern(footer);
-            // Remove footer first (from end)
-            if (footerPattern) {
-                cleaned = cleaned.replace(new RegExp(footerPattern + '$'), '');
-            }
-            // Remove header (from start)
-            if (headerPattern) {
-                cleaned = cleaned.replace(new RegExp('^' + headerPattern), '');
-            }
-        }
-        return cleaned.trim();
-    }
-    /**
-     * Create regex pattern from wrapper text, handling placeholders
-     */
-    escapeRegexAndCreatePattern(wrapper) {
-        // Replace placeholders with generic patterns
-        let pattern = wrapper
-            .replace(/\{name\}/g, '[^}]*') // Replace {name} with pattern to match any name
-            .replace(/\{[^}]+\}/g, '[^}]*'); // Replace any other {placeholder}
-        // Escape special regex characters
-        pattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        // Convert \n back to actual newlines in pattern
-        pattern = pattern.replace(/\\n/g, '\\s*\\n\\s*');
-        return pattern;
-    }
-    /**
-     * Fallback: Strip generic comments when no fieldMapping available
-     */
-    stripGenericComments(content, type) {
         let cleaned = content;
+        // STEP 1: Remove ALL HTML comment variations (multiple times if needed)
+        if (type === 'html') {
+            let previousLength;
+            do {
+                previousLength = cleaned.length;
+                // Remove ServiceNow Widget Template comments (all variations)
+                cleaned = cleaned.replace(/^\s*<!--\s*ServiceNow\s+Widget\s+Template[\s\S]*?-->\s*\n?/gmi, '');
+                // Remove Angular bindings comments
+                cleaned = cleaned.replace(/^\s*<!--\s*Angular\s+bindings[\s\S]*?-->\s*\n?/gmi, '');
+                // Remove any other HTML comments at start
+                cleaned = cleaned.replace(/^\s*<!--[\s\S]*?-->\s*\n?/gm, '');
+            } while (cleaned.length !== previousLength); // Keep going until no more changes
+        }
+        // STEP 2: Remove ALL JS comment variations (multiple times if needed)
         if (type === 'js') {
-            // Remove generic comment blocks at start
-            cleaned = cleaned.replace(/^\/\*\*[\s\S]*?\*\/\s*\n?/, '');
-            // Remove simple function wrappers (conservative approach)
-            cleaned = cleaned.replace(/^\(function\(\) \{\s*\n?/, '');
-            cleaned = cleaned.replace(/\s*\n?\}\)\(\);\s*$/, '');
-            cleaned = cleaned.replace(/^function\(\s*/, 'function(');
-        }
-        else if (type === 'html') {
-            // Remove HTML comments
-            cleaned = cleaned.replace(/^<!--[\s\S]*?-->\s*\n?/, '');
-        }
-        else if (type === 'css') {
-            // Remove CSS comments
-            cleaned = cleaned.replace(/^\/\*[\s\S]*?\*\/\s*\n?/, '');
-        }
+            let previousLength;
+            do {
+                previousLength = cleaned.length;
+                // Remove Server/Client script comment blocks
+                cleaned = cleaned.replace(/^\s*\/\*\*[\s\S]*?\*\/\s*\n?/gm, '');
+                // Remove function wrappers
+                cleaned = cleaned.replace(/^\s*\(function\s*\(\s*\)\s*\{\s*\n?/gm, '');
+                cleaned = cleaned.replace(/\s*\n?\s*\}\s*\)\s*\(\s*\)\s*;?\s*$/gm, '');
+                // Remove function( wrappers for client scripts
+                cleaned = cleaned.replace(/^\s*function\s*\(\s*$/gm, '');
+                cleaned = cleaned.replace(/^\s*\)\s*$/gm, '');
+            } while (cleaned.length !== previousLength);
+        }
+        // STEP 3: Remove ALL CSS comment variations
+        if (type === 'css') {
+            let previousLength;
+            do {
+                previousLength = cleaned.length;
+                // Remove widget style comments
+                cleaned = cleaned.replace(/^\s*\/\*[\s\S]*?\*\/\s*\n?/gm, '');
+            } while (cleaned.length !== previousLength);
+        }
+        // STEP 4: Clean up excessive whitespace
+        cleaned = cleaned.replace(/^\s*\n+/gm, ''); // Remove empty lines at start
+        cleaned = cleaned.replace(/\n\s*$/gm, ''); // Remove trailing whitespace
         return cleaned.trim();
     }
     /**
-     * INTELLIGENT WRAPPER DETECTION: Check if content actually needs wrappers
+     * CONSERVATIVE WRAPPER DETECTION: Only add wrappers if content is truly minimal
+     * FIXED: Now properly detects ALL types of existing wrappers/comments
      */
     needsWrappers(content, mapping) {
         if (!content || !content.trim()) {
             return false; // Empty content doesn't need wrappers
         }
-        // Check for server script wrappers
-        if (mapping.wrapperHeader?.includes('(function()') && mapping.wrapperFooter?.includes('})()')) {
-            // Check if content already has function wrapper
-            const trimmed = content.trim();
-            if (trimmed.match(/^\(function\s*\([^)]*\)\s*\{[\s\S]*\}\s*\)\s*\([^)]*\)\s*;?$/)) {
-                return false; // Already has function wrapper
-            }
-            if (trimmed.match(/^\(function\(\)\s*\{[\s\S]*\}\)\(\)\s*;?$/)) {
-                return false; // Already has our specific wrapper
-            }
+        const trimmed = content.trim();
+        // CONSERVATIVE APPROACH: If content has ANY of these indicators, skip wrappers
+        // 1. Already has HTML comments (ANY HTML comments)
+        if (trimmed.includes('<!--')) {
+            console.log(`   🔍 Detected existing HTML comments - skipping wrappers`);
+            return false;
         }
-        // Check for client script wrappers
-        if (mapping.wrapperHeader?.includes('function(') && mapping.wrapperFooter?.includes(')')) {
-            const trimmed = content.trim();
-            if (trimmed.match(/^function\s*\([^)]*\)\s*\{[\s\S]*\}$/)) {
-                return false; // Already is a function
-            }
+        // 2. Already has JS comments (ANY block comments)
+        if (trimmed.includes('/**') || trimmed.includes('/*')) {
+            console.log(`   🔍 Detected existing JS comments - skipping wrappers`);
+            return false;
+        }
+        // 3. Already has function wrappers (ANY function patterns)
+        if (trimmed.includes('(function') || trimmed.match(/^function\s*\(/)) {
+            console.log(`   🔍 Detected existing function patterns - skipping wrappers`);
+            return false;
         }
-        // Check if content already has comments that look like ours
-        if (mapping.wrapperHeader?.includes('/**')) {
-            if (content.includes('* Server Script for Widget:') ||
-                content.includes('* Client Controller for Widget:') ||
-                content.includes('* ES5 ONLY -')) {
-                return false; // Already has our comments
+        // 4. Content is substantial (more than just basic code)
+        if (trimmed.length > 200) {
+            console.log(`   🔍 Content is substantial (${trimmed.length} chars) - skipping wrappers`);
+            return false;
+        }
+        // 5. Contains ServiceNow-specific patterns
+        const serviceNowPatterns = [
+            'data.', 'input.', 'options.', '$scope.', 'c.server', 'gs.', '$sp.',
+            'ng-', 'angular', 'spModal', 'spUtil', '{{', 'glide'
+        ];
+        for (const pattern of serviceNowPatterns) {
+            if (trimmed.toLowerCase().includes(pattern.toLowerCase())) {
+                console.log(`   🔍 Detected ServiceNow pattern '${pattern}' - skipping wrappers`);
+                return false;
             }
         }
-        return true; // Content needs wrappers
+        // ONLY add wrappers for truly minimal/empty content
+        console.log(`   ✨ Content is minimal and clean - adding wrappers`);
+        return true;
     }
     /**
      * Sanitize filename for filesystem
@@ -704,26 +703,55 @@ snow-flow sync status ${widget.sys_id}
     }
     /**
      * Pull any supported artifact type by detecting table from sys_id
+     * ENHANCED: Better error logging and more robust detection
      */
     async pullArtifactBySysId(sys_id) {
-        // Try to detect table by querying common tables
-        const tables = Object.keys(artifact_registry_1.ARTIFACT_REGISTRY);
+        console.log(`\n🔍 Auto-detecting artifact type for sys_id: ${sys_id}`);
+        console.log(`📋 Checking ${Object.keys(artifact_registry_1.ARTIFACT_REGISTRY).length} supported tables...`);
+        // SMART ORDER: Check most common tables first for better performance
+        const allTables = Object.keys(artifact_registry_1.ARTIFACT_REGISTRY);
+        const commonTables = ['sp_widget', 'sys_script_include', 'sys_script', 'sys_ui_page'];
+        const otherTables = allTables.filter(t => !commonTables.includes(t));
+        const tables = [...commonTables, ...otherTables]; // Common tables first
         const timeoutConfig = (0, mcp_timeout_config_js_1.getMCPTimeoutConfig)();
+        const errors = [];
         for (const table of tables) {
             try {
-                // Quick query with short timeout
-                const response = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.searchRecords(table, `sys_id=${sys_id}`, 1), 3000, // 3 second timeout for detection
+                console.log(`   🔎 Checking table: ${table}...`);
+                // Increased timeout for better reliability
+                const response = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.searchRecords(table, `sys_id=${sys_id}`, 1), 8000, // 8 second timeout per table (was 3s)
                 `Detect table for ${sys_id}`);
                 if (response.result?.[0]) {
-                    console.log(`🎆 Found artifact in table: ${table}`);
+                    console.log(`   ✅ Found in table: ${table}`);
+                    console.log(`🎆 Auto-detection successful! Proceeding with pull...`);
                     return this.pullArtifact(table, sys_id);
                 }
+                else {
+                    console.log(`   ❌ Not found in: ${table}`);
+                }
             }
             catch (error) {
-                // Table might not exist, continue searching
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.log(`   ⚠️ Error checking ${table}: ${errorMsg}`);
+                errors.push({ table, error: errorMsg });
+                // Don't fail on permission errors, timeouts, etc. - keep trying other tables
             }
         }
-        throw new Error(`Could not find artifact with sys_id ${sys_id} in any supported table`);
+        // Generate detailed error message
+        console.log(`\n❌ Artifact detection failed!`);
+        console.log(`🔍 Searched ${tables.length} tables for sys_id: ${sys_id}`);
+        if (errors.length > 0) {
+            console.log(`\n⚠️ Errors encountered:`);
+            errors.forEach(({ table, error }) => {
+                console.log(`   ${table}: ${error}`);
+            });
+        }
+        console.log(`\n💡 Troubleshooting tips:`);
+        console.log(`   1. Verify the sys_id exists in ServiceNow`);
+        console.log(`   2. Check your permissions for the target table`);
+        console.log(`   3. Try specifying the table explicitly: snow_pull_artifact({sys_id, table: 'sp_widget'})`);
+        console.log(`   4. Supported tables: ${tables.join(', ')}`);
+        throw new Error(`Could not find artifact with sys_id ${sys_id} in any supported table. See details above.`);
     }
     /**
      * Get supported artifact types

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.5.15",
-  "description": "ServiceNow development framework with FIXED local artifact sync system. CRITICAL BUG RESOLVED: Fixed cumulative wrapper problems in snow_pull_artifact where dynamic registry wrappers didn't match hardcoded strip patterns, causing dubbele function wrappers. Now features intelligent wrapper detection and proper content handling. Enhanced 'snow-flow init' creates optimized settings.json with 18 MCP servers, extensive development permissions, intelligent hooks, and ServiceNow-specific commands. Features intelligent timeout configuration and comprehensive ServiceNow development workflow.",
+  "version": "3.5.17",
+  "description": "ServiceNow development framework with ROBUST artifact detection fix. v3.5.17 FIXES the intermittent 'Could not find artifact' errors in snow_pull_artifact. Enhanced pullArtifactBySysId with detailed error logging, longer timeouts (8s per table), smart table ordering, and comprehensive troubleshooting guidance. ULTRA-CONSERVATIVE wrapper system prevents duplicate HTML comments. Enhanced 'snow-flow init' creates optimized settings.json with 18 MCP servers, extensive development permissions, intelligent hooks, and ServiceNow-specific commands. Features intelligent timeout configuration and comprehensive ServiceNow development workflow.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {