snow-flow 3.5.14 → 3.5.16

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

@@ -31,6 +31,8 @@ export interface LocalFile {
     currentContent?: string;
     isModified: boolean;
     fieldMapping?: FieldMapping;
+    existedBefore?: boolean;
+    previousContent?: string;
 }
 export declare class ArtifactLocalSync {
     private baseDir;
@@ -84,9 +86,15 @@ export declare class ArtifactLocalSync {
      */
     private validateES5;
     /**
-     * Strip headers/footers we added - now uses field mapping for accuracy
+     * AGGRESSIVE STRIP FUNCTION: Remove ALL possible Snow-Flow wrapper variations
+     * FIXED: Handles multiple/nested wrappers and all patterns
      */
     private stripAddedWrappers;
+    /**
+     * CONSERVATIVE WRAPPER DETECTION: Only add wrappers if content is truly minimal
+     * FIXED: Now properly detects ALL types of existing wrappers/comments
+     */
+    private needsWrappers;
     /**
      * Sanitize filename for filesystem
      */

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

@@ -127,6 +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.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
@@ -186,9 +188,22 @@ class ArtifactLocalSync {
                 .replace('{name}', sanitizedName)
                 .replace('{api_name}', artifactData.api_name || sanitizedName)
                 .replace('{short_description}', artifactData.short_description || sanitizedName);
-            // Generate header/footer with replacements
-            const header = this.replacePlaceholders(mapping.wrapperHeader || '', artifactData);
-            const footer = this.replacePlaceholders(mapping.wrapperFooter || '', artifactData);
+            // ULTRA-CONSERVATIVE WRAPPER SYSTEM: When in doubt, don't add wrappers
+            let header = '';
+            let footer = '';
+            // 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;
             files.push(file);
@@ -370,6 +385,31 @@ class ArtifactLocalSync {
     createLocalFile(dirPath, filename, content, field, type, header = '', footer = '') {
         const filePath = path.join(dirPath, filename);
         const fullContent = header + content + footer;
+        // CRITICAL FIX: Check if file exists and handle overwrites intelligently
+        let fileExists = false;
+        let existingContent = '';
+        if (fs.existsSync(filePath)) {
+            fileExists = true;
+            existingContent = fs.readFileSync(filePath, 'utf8');
+            // Check if existing content is the same (avoid unnecessary writes)
+            if (existingContent === fullContent) {
+                console.log(`   📄 Unchanged: ${filename} (identical content, skipping write)`);
+                return {
+                    filename,
+                    path: filePath,
+                    field,
+                    type: type,
+                    originalContent: content,
+                    isModified: false
+                };
+            }
+            console.log(`   🔄 Overwriting: ${filename}`);
+            console.log(`   ℹ️ File size: ${existingContent.length} → ${fullContent.length} chars`);
+        }
+        else {
+            console.log(`   📝 Creating: ${filename}`);
+        }
+        // Write the file
         fs.writeFileSync(filePath, fullContent, 'utf8');
         return {
             filename,
@@ -377,7 +417,9 @@ class ArtifactLocalSync {
             field,
             type: type,
             originalContent: content,
-            isModified: false
+            isModified: fileExists, // Mark as modified if we overwrote existing file
+            existedBefore: fileExists,
+            previousContent: existingContent
         };
     }
     /**
@@ -544,28 +586,97 @@ snow-flow sync status ${widget.sys_id}
         return issues;
     }
     /**
-     * Strip headers/footers we added - now uses field mapping for accuracy
+     * AGGRESSIVE STRIP FUNCTION: Remove ALL possible Snow-Flow wrapper variations
+     * FIXED: Handles multiple/nested wrappers and all patterns
      */
     stripAddedWrappers(content, type, fieldMapping) {
-        // Remove our added comments and wrappers
         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 wrapper function if we added it
-            cleaned = cleaned.replace(/^\(function\(\) \{\n/, '');
-            cleaned = cleaned.replace(/\n\}\)\(\);$/, '');
-            // Remove our header comments
-            cleaned = cleaned.replace(/^\/\*\*[\s\S]*?\*\/\n\n/, '');
-            cleaned = cleaned.replace(/^function\(/, 'function(');
+            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();
+    }
+    /**
+     * 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
+        }
+        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;
         }
-        else if (type === 'html') {
-            // Remove our HTML comments
-            cleaned = cleaned.replace(/^<!-- ServiceNow Widget Template -->[\s\S]*?-->\n\n/, '');
+        // 2. Already has JS comments (ANY block comments)
+        if (trimmed.includes('/**') || trimmed.includes('/*')) {
+            console.log(`   🔍 Detected existing JS comments - skipping wrappers`);
+            return false;
         }
-        else if (type === 'css') {
-            // Remove our CSS comments
-            cleaned = cleaned.replace(/^\/\* ServiceNow Widget Styles \*\/[\s\S]*?\*\/\n\n/, '');
+        // 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;
         }
-        return cleaned.trim();
+        // 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;
+            }
+        }
+        // ONLY add wrappers for truly minimal/empty content
+        console.log(`   ✨ Content is minimal and clean - adding wrappers`);
+        return true;
     }
     /**
      * Sanitize filename for filesystem

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.5.14",
-  "description": "ServiceNow development framework with comprehensive Claude Code integration. Enhanced 'snow-flow init' creates optimized settings.json with 18 MCP servers, extensive development permissions, intelligent hooks, and ServiceNow-specific commands. Fixed false positive success reporting in artifact push. Features intelligent timeout configuration for long operations while preventing Claude API timeouts. Executes background scripts using ES5 JavaScript only (ServiceNow Rhino engine requirement). Provides complete development workflow with local artifact sync, widget debugging, deployment validation, and comprehensive platform management.",
+  "version": "3.5.16",
+  "description": "ServiceNow development framework with EMERGENCY FIX for wrapper multiplication bug. v3.5.16 FIXES the triple/quadruple wrapper problem in v3.5.15. Features ULTRA-CONSERVATIVE wrapper system that aggressively strips ALL wrapper variations and only adds wrappers for truly minimal content (<50 chars). No more duplicate HTML comments or function wrappers. 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": {