@dbcube/cli 4.1.2 → 4.1.4

package/bun.lock

@@ -4,7 +4,7 @@
     "": {
       "name": "@dbcube/cli",
       "dependencies": {
-        "@dbcube/schema-builder": "^4.1.2",
+        "@dbcube/schema-builder": "^4.1.4",
         "@inquirer/prompts": "^8.0.2",
         "alwait": "^1.0.0",
         "chalk": "^5.6.2",
@@ -12,13 +12,14 @@
         "fs-extra": "^11.3.2",
         "glob": "^13.0.0",
         "ora": "^9.0.0",
+        "unzipper": "^0.12.3",
       },
     },
   },
   "packages": {
-    "@dbcube/core": ["@dbcube/core@4.1.5", "", { "dependencies": { "chalk": "^5.6.2", "deasync": "^0.1.31", "follow-redirects": "^1.15.11", "ora": "^9.0.0", "unzipper": "^0.12.3" }, "bin": { "dbcube-core": "dist/bin.cjs" } }, "sha512-LNzdRCquA/6Thdh8QindNd9BBywX8nnrXrPM2yS6eUuIP9pUlDMuoV/PBVkU8761R71eMNKkIFqKEzIP+wreZA=="],
+    "@dbcube/core": ["@dbcube/core@4.1.7", "", { "dependencies": { "chalk": "^5.6.2", "deasync": "^0.1.31", "follow-redirects": "^1.15.11", "ora": "^9.0.0", "unzipper": "^0.12.3" }, "bin": { "dbcube-core": "dist/bin.cjs" } }, "sha512-/2VwxVOHil8QJ+ZcN/l1Qj/R5wqVJG6Swk0Quf1YmD1c+OsNmW9BZt/v3Ncpb+X8YZXdxRibeJU3AMtXXy425w=="],
 
-    "@dbcube/schema-builder": ["@dbcube/schema-builder@4.1.2", "", { "dependencies": { "@dbcube/core": "^4.1.5", "chalk": "^5.6.2", "ora": "^9.0.0" } }, "sha512-bGU9e7w17KVIy8TUIajWYAZlGmfod7Cm75T+432M2uiqCxMuLstivbJhOnTu3BYzU/in4UXzftpDiY2q11Uu/Q=="],
+    "@dbcube/schema-builder": ["@dbcube/schema-builder@4.1.4", "", { "dependencies": { "@dbcube/core": "^4.1.7", "chalk": "^5.6.2", "ora": "^9.0.0" } }, "sha512-AnjOFxd7BqKOHEIg0OUuLiEQtoH5NyDUn5dENQxiiX544Pgd3Y4f/VFj2kRR1CU/MFmwrQRGypum4AX5W9cEEA=="],
 
     "@inquirer/ansi": ["@inquirer/ansi@2.0.2", "", {}, "sha512-SYLX05PwJVnW+WVegZt1T4Ip1qba1ik+pNJPDiqvk6zS5Y/i8PhRzLpGEtVd7sW0G8cMtkD8t4AZYhQwm8vnww=="],
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbcube/cli",
-  "version": "4.1.2",
+  "version": "4.1.4",
   "main": "index.js",
   "scripts": {
     "dbcube": "node src/index.js"
@@ -13,13 +13,14 @@
   "license": "ISC",
   "description": "",
   "dependencies": {
-    "@dbcube/schema-builder": "^4.1.2",
+    "@dbcube/schema-builder": "^4.1.4",
     "@inquirer/prompts": "^8.0.2",
     "alwait": "^1.0.0",
     "chalk": "^5.6.2",
     "dotenv": "^17.2.3",
     "fs-extra": "^11.3.2",
     "glob": "^13.0.0",
-    "ora": "^9.0.0"
+    "ora": "^9.0.0",
+    "unzipper": "^0.12.3"
   }
 }

package/src/commands/help.js

@@ -28,10 +28,10 @@ async function showHelp() {
         console.log(`  ${chalk.yellow('run seeder:add')}            ${chalk.white('Add test data from seeder .cube files')}\n`);
 
         console.log(`${chalk.cyan.bold('BINARY MANAGEMENT:')}`);
+        console.log(`  ${chalk.yellow('update')}                    ${chalk.white('Check and update binaries to latest version')}`);
         console.log(`  ${chalk.yellow('run download')}              ${chalk.white('Download binaries interactively')}`);
         console.log(`  ${chalk.yellow('run download <engine>')}     ${chalk.white('Download specific engine (latest version)')}`);
         console.log(`  ${chalk.yellow('run download <engine> <ver>')} ${chalk.white('Download specific engine version')}`);
-        console.log(`  ${chalk.yellow('run upgrade')}               ${chalk.white('Update all binaries to latest version')}`);
         console.log(`  ${chalk.gray('  Engines:')} query-engine, schema-engine, sqlite-engine\n`);
 
         console.log(`${chalk.cyan.bold('UTILITY COMMANDS:')}`);
@@ -58,8 +58,8 @@ async function showHelp() {
         console.log(`  ${chalk.gray('# Download a specific binary version')}`);
         console.log(`  ${chalk.white('npx dbcube run download query-engine v3.1.1')}\n`);
 
-        console.log(`  ${chalk.gray('# Upgrade all binaries to latest version')}`);
-        console.log(`  ${chalk.white('npx dbcube run upgrade')}\n`);
+        console.log(`  ${chalk.gray('# Check and update binaries if needed')}`);
+        console.log(`  ${chalk.white('npx dbcube update')}\n`);
         
         console.log(`${chalk.cyan.bold('CONFIGURATION:')}`);
         console.log(`  ${chalk.white('Create a')} ${chalk.yellow('dbcube.config.js')} ${chalk.white('file in your project root:')}`);

package/src/commands/update.js

@@ -0,0 +1,417 @@
+#!/usr/bin/env node
+const { default: chalk } = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const https = require('https');
+const os = require('os');
+const unzipper = require('unzipper');
+const ora = require('ora');
+
+const VERSION_URLS = {
+    'query-engine': 'https://raw.githubusercontent.com/Dbcube/binaries/main/query-engines.json',
+    'schema-engine': 'https://raw.githubusercontent.com/Dbcube/binaries/main/schema-engines.json',
+    'sqlite-engine': 'https://raw.githubusercontent.com/Dbcube/binaries/main/sqlite-engines.json'
+};
+
+const BINARY_PREFIX_MAP = {
+    'query-engine': 'query',
+    'schema-engine': 'schema',
+    'sqlite-engine': 'sqlite'
+};
+
+const PLATFORM_MAP = {
+    win32: 'windows',
+    linux: 'linux',
+    darwin: 'macos'
+};
+
+const ARCH_MAP = {
+    x64: 'x64',
+    arm64: 'arm64'
+};
+
+function getPlatformInfo() {
+    const platform = PLATFORM_MAP[process.platform];
+    const arch = ARCH_MAP[process.arch];
+
+    if (!platform || !arch) {
+        throw new Error(`Plataforma no soportada: ${process.platform} ${process.arch}`);
+    }
+
+    return { platform, arch };
+}
+
+function getBinDir() {
+    const possibleDirs = [
+        path.resolve(process.cwd(), '.dbcube', 'bin'),
+        path.resolve(process.cwd(), 'node_modules', '.dbcube', 'bin'),
+    ];
+
+    for (const dir of possibleDirs) {
+        try {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            return dir;
+        } catch {
+            continue;
+        }
+    }
+
+    const tempDir = path.join(os.tmpdir(), '.dbcube', 'bin');
+    fs.mkdirSync(tempDir, { recursive: true });
+    return tempDir;
+}
+
+/**
+ * Fetch latest version from GitHub
+ */
+function fetchLatestVersion(engineType) {
+    const url = VERSION_URLS[engineType];
+
+    return new Promise((resolve, reject) => {
+        https.get(url, (response) => {
+            let data = '';
+
+            response.on('data', (chunk) => {
+                data += chunk;
+            });
+
+            response.on('end', () => {
+                try {
+                    const versions = JSON.parse(data);
+                    if (versions && versions.length > 0) {
+                        // Get the latest version (first in array)
+                        resolve(versions[0].version);
+                    } else {
+                        reject(new Error('No versions found'));
+                    }
+                } catch (error) {
+                    reject(error);
+                }
+            });
+
+            response.on('error', reject);
+        }).on('error', reject);
+    });
+}
+
+/**
+ * Extract version from binary filename
+ * Example: schema-engine-v1.0.0-windows-x64.exe -> v1.0.0
+ */
+function extractVersionFromFilename(filename) {
+    const match = filename.match(/-(v\d+\.\d+\.\d+)-/);
+    return match ? match[1] : null;
+}
+
+/**
+ * Get local version of installed binary
+ */
+function getLocalVersion(binDir, prefix) {
+    try {
+        const files = fs.readdirSync(binDir);
+        const binaryPattern = new RegExp(`^${prefix}-engine-v`);
+        const binaryFile = files.find(f => binaryPattern.test(f));
+
+        if (binaryFile) {
+            return extractVersionFromFilename(binaryFile);
+        }
+    } catch (error) {
+        // Directory doesn't exist or can't read
+    }
+    return null;
+}
+
+/**
+ * Compare versions (returns true if remote is newer)
+ */
+function isNewerVersion(localVersion, remoteVersion) {
+    if (!localVersion) return true; // No local version, download
+
+    // Remove 'v' prefix if exists
+    const cleanLocal = localVersion.replace(/^v/, '');
+    const cleanRemote = remoteVersion.replace(/^v/, '');
+
+    const localParts = cleanLocal.split('.').map(Number);
+    const remoteParts = cleanRemote.split('.').map(Number);
+
+    for (let i = 0; i < 3; i++) {
+        if (remoteParts[i] > localParts[i]) return true;
+        if (remoteParts[i] < localParts[i]) return false;
+    }
+
+    return false; // Versions are equal
+}
+
+/**
+ * Delete old binary files
+ */
+function deleteOldBinary(binDir, prefix) {
+    try {
+        const files = fs.readdirSync(binDir);
+        const binaryPattern = new RegExp(`^${prefix}-engine-`);
+
+        files.forEach(file => {
+            if (binaryPattern.test(file)) {
+                const filePath = path.join(binDir, file);
+                try {
+                    fs.unlinkSync(filePath);
+                    console.log(chalk.gray(`   🗑️  Deleted: ${file}`));
+                } catch (err) {
+                    console.warn(chalk.yellow(`   ⚠️  Could not delete: ${file}`));
+                }
+            }
+        });
+    } catch (error) {
+        // Ignore errors
+    }
+}
+
+async function updateBinary(engineType, localVersion, remoteVersion) {
+    const spinner = ora(`Updating ${engineType}...`).start();
+
+    try {
+        const { platform, arch } = getPlatformInfo();
+        const prefix = BINARY_PREFIX_MAP[engineType];
+
+        if (!prefix) {
+            throw new Error(`Tipo de binario no soportado: ${engineType}`);
+        }
+
+        const baseName = `${prefix}-engine-${remoteVersion}-${platform}-${arch}`;
+        const binaryName = platform === 'windows' ? `${baseName}.exe` : baseName;
+
+        // Build download URL
+        const url = `https://github.com/Dbcube/binaries/releases/download/${prefix}-engine/${prefix}-engine-${remoteVersion}-${platform}-${arch}.zip`;
+
+        const binDir = getBinDir();
+        const finalBinaryPath = path.join(binDir, binaryName);
+
+        spinner.text = `Deleting old ${engineType} (${localVersion || 'none'})...`;
+
+        // Delete old binary first
+        deleteOldBinary(binDir, prefix);
+
+        const tempZipPath = path.join(os.tmpdir(), `dbcube-${prefix}-${Date.now()}.zip`);
+
+        spinner.text = `Downloading ${engineType} ${remoteVersion}...`;
+
+        // Download
+        await downloadFile(url, tempZipPath, (progress) => {
+            const percentage = progress.percentage.toFixed(1);
+            const downloaded = (progress.downloaded / 1024 / 1024).toFixed(1);
+            const total = (progress.total / 1024 / 1024).toFixed(1);
+            spinner.text = `Downloading ${chalk.cyan(engineType)} ${chalk.yellow(remoteVersion)}: ${percentage}% (${downloaded}/${total}MB)`;
+        });
+
+        spinner.text = `Extracting ${engineType}...`;
+
+        // Extract
+        await extractBinary(tempZipPath, finalBinaryPath);
+
+        // Cleanup
+        cleanupFile(tempZipPath);
+
+        spinner.succeed(chalk.green(`✓ ${engineType} updated: ${localVersion || 'none'} → ${remoteVersion}`));
+        console.log(chalk.gray(`   Location: ${finalBinaryPath}`));
+
+        return true;
+
+    } catch (error) {
+        spinner.fail(chalk.red(`✗ Error updating ${engineType}`));
+        console.error(chalk.red(`   ${error.message}`));
+        return false;
+    }
+}
+
+function downloadFile(url, outputPath, onProgress) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { timeout: 30000 }, (response) => {
+            // Handle redirects
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                const redirectUrl = response.headers.location;
+                if (redirectUrl) {
+                    return downloadFile(redirectUrl, outputPath, onProgress).then(resolve).catch(reject);
+                }
+            }
+
+            if (response.statusCode !== 200) {
+                reject(new Error(`HTTP ${response.statusCode}: Binary not found for this version`));
+                return;
+            }
+
+            const file = fs.createWriteStream(outputPath);
+            const totalBytes = parseInt(response.headers['content-length'] || '0', 10);
+            let downloadedBytes = 0;
+
+            response.on('data', (chunk) => {
+                downloadedBytes += chunk.length;
+                file.write(chunk);
+
+                if (totalBytes > 0 && onProgress) {
+                    onProgress({
+                        downloaded: downloadedBytes,
+                        total: totalBytes,
+                        percentage: (downloadedBytes / totalBytes) * 100
+                    });
+                }
+            });
+
+            response.on('end', () => {
+                file.end();
+                resolve();
+            });
+
+            response.on('error', (err) => {
+                file.close();
+                cleanupFile(outputPath);
+                reject(err);
+            });
+
+            file.on('error', (err) => {
+                file.close();
+                cleanupFile(outputPath);
+                reject(err);
+            });
+        }).on('error', reject).on('timeout', () => {
+            reject(new Error('Download timeout'));
+        });
+    });
+}
+
+function extractBinary(zipPath, outputPath) {
+    return new Promise((resolve, reject) => {
+        let extracted = false;
+
+        fs.createReadStream(zipPath)
+            .pipe(unzipper.Parse())
+            .on('entry', (entry) => {
+                if (entry.type === 'File' && !extracted) {
+                    extracted = true;
+                    const writeStream = fs.createWriteStream(outputPath);
+
+                    entry.pipe(writeStream);
+
+                    writeStream.on('finish', () => {
+                        if (process.platform !== 'win32') {
+                            fs.chmodSync(outputPath, 0o755);
+                        }
+                        resolve();
+                    });
+
+                    writeStream.on('error', (err) => {
+                        reject(err);
+                    });
+                } else {
+                    entry.autodrain();
+                }
+            })
+            .on('error', (err) => {
+                reject(err);
+            })
+            .on('close', () => {
+                if (!extracted) {
+                    reject(new Error('No valid file found in ZIP'));
+                }
+            });
+    });
+}
+
+function cleanupFile(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    } catch {
+        // Ignore cleanup errors
+    }
+}
+
+async function main() {
+    console.log(chalk.blue('\n🔄 Dbcube Update - Check and Update Binaries\n'));
+
+    const binDir = getBinDir();
+    const binaries = ['query-engine', 'schema-engine', 'sqlite-engine'];
+
+    const spinner = ora('Checking versions...').start();
+
+    const updates = [];
+
+    // Check all binaries
+    for (const engineType of binaries) {
+        try {
+            const prefix = BINARY_PREFIX_MAP[engineType];
+            const localVersion = getLocalVersion(binDir, prefix);
+            const remoteVersion = await fetchLatestVersion(engineType);
+            const needsUpdate = isNewerVersion(localVersion, remoteVersion);
+
+            updates.push({
+                engineType,
+                localVersion,
+                remoteVersion,
+                needsUpdate
+            });
+
+        } catch (error) {
+            console.warn(chalk.yellow(`\n⚠️  Could not check ${engineType}: ${error.message}`));
+        }
+    }
+
+    spinner.stop();
+
+    // Show status
+    console.log(chalk.cyan('📊 Version Status:\n'));
+
+    let updatesAvailable = 0;
+
+    for (const update of updates) {
+        if (update.needsUpdate) {
+            console.log(chalk.yellow(`   📦 ${update.engineType}: ${update.localVersion || 'not installed'} → ${update.remoteVersion}`));
+            updatesAvailable++;
+        } else if (update.localVersion) {
+            console.log(chalk.green(`   ✅ ${update.engineType}: ${update.localVersion} (up to date)`));
+        } else {
+            console.log(chalk.gray(`   ℹ️  ${update.engineType}: not installed`));
+        }
+    }
+
+    if (updatesAvailable === 0) {
+        console.log(chalk.green('\n✨ All binaries are up to date!\n'));
+        return;
+    }
+
+    console.log(chalk.cyan(`\n🔄 Updating ${updatesAvailable} binary(ies)...\n`));
+
+    // Update binaries
+    let successCount = 0;
+    let failCount = 0;
+
+    for (const update of updates) {
+        if (update.needsUpdate) {
+            const success = await updateBinary(update.engineType, update.localVersion, update.remoteVersion);
+            if (success) {
+                successCount++;
+            } else {
+                failCount++;
+            }
+        }
+    }
+
+    // Summary
+    console.log('');
+    if (failCount === 0) {
+        console.log(chalk.green.bold(`✅ All binaries (${successCount}/${updatesAvailable}) updated successfully!\n`));
+    } else if (successCount > 0) {
+        console.log(chalk.yellow.bold(`⚠️  Partial update: ${successCount}/${updatesAvailable} binaries updated\n`));
+        process.exit(1);
+    } else {
+        console.log(chalk.red.bold(`❌ No binaries were updated\n`));
+        process.exit(1);
+    }
+}
+
+main().catch(err => {
+    console.error(chalk.red('\n❌ Unexpected error:'), err.message);
+    process.exit(1);
+});

package/src/index.js

@@ -47,7 +47,9 @@ const commandMap = {
   'run:database:create:physical': '../src/commands/run/database/create/createDatabase.js',
 
   'run:download': '../src/commands/run/download.js',
-  'run:upgrade': '../src/commands/run/upgrade.js',
+  'run:update': '../src/commands/run/update.js',
+
+  'update': '../src/commands/update.js',
 
   '--version': '../src/commands/version.js',
   '-v': '../src/commands/version.js',

package/src/commands/run/upgrade.js

@@ -1,302 +0,0 @@
-#!/usr/bin/env node
-const chalk = require('chalk');
-const path = require('path');
-const fs = require('fs');
-const https = require('https');
-const os = require('os');
-const unzipper = require('unzipper');
-const ora = require('ora');
-
-const BINARIES = ['query-engine', 'schema-engine', 'sqlite-engine'];
-
-const BINARY_PREFIX_MAP = {
-    'query-engine': 'query',
-    'schema-engine': 'schema',
-    'sqlite-engine': 'sqlite'
-};
-
-const PLATFORM_MAP = {
-    win32: 'windows',
-    linux: 'linux',
-    darwin: 'macos'
-};
-
-const ARCH_MAP = {
-    x64: 'x64',
-    arm64: 'arm64'
-};
-
-function getPlatformInfo() {
-    const platform = PLATFORM_MAP[process.platform];
-    const arch = ARCH_MAP[process.arch];
-
-    if (!platform || !arch) {
-        throw new Error(`Plataforma no soportada: ${process.platform} ${process.arch}`);
-    }
-
-    return { platform, arch };
-}
-
-function getBinDir() {
-    const possibleDirs = [
-        path.resolve(process.cwd(), '.dbcube', 'bin'),
-        path.resolve(process.cwd(), 'node_modules', '.dbcube', 'bin'),
-    ];
-
-    for (const dir of possibleDirs) {
-        try {
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            return dir;
-        } catch {
-            continue;
-        }
-    }
-
-    const tempDir = path.join(os.tmpdir(), '.dbcube', 'bin');
-    fs.mkdirSync(tempDir, { recursive: true });
-    return tempDir;
-}
-
-function cleanBinDirectory(binDir) {
-    if (!fs.existsSync(binDir)) {
-        return 0;
-    }
-
-    const files = fs.readdirSync(binDir);
-    let deletedCount = 0;
-
-    for (const file of files) {
-        const filePath = path.join(binDir, file);
-        try {
-            const stat = fs.statSync(filePath);
-            if (stat.isFile()) {
-                fs.unlinkSync(filePath);
-                deletedCount++;
-            }
-        } catch (err) {
-            console.warn(chalk.yellow(`⚠️  No se pudo eliminar: ${file}`));
-        }
-    }
-
-    return deletedCount;
-}
-
-async function downloadBinary(engineType, version, spinner) {
-    const { platform, arch } = getPlatformInfo();
-    const prefix = BINARY_PREFIX_MAP[engineType];
-
-    if (!prefix) {
-        throw new Error(`Tipo de binario no soportado: ${engineType}`);
-    }
-
-    const baseName = `${prefix}-engine-${platform}-${arch}`;
-    const binaryName = platform === 'windows' ? `${baseName}.exe` : baseName;
-
-    // Build download URL
-    const versionTag = version === 'latest' ? version : `v${version}`;
-    const url = `https://github.com/Dbcube/binaries/releases/download/${prefix}-engine/${prefix}-engine-${versionTag}-${platform}-${arch}.zip`;
-
-    const binDir = getBinDir();
-    const tempZipPath = path.join(os.tmpdir(), `dbcube-${prefix}-${Date.now()}.zip`);
-    const finalBinaryPath = path.join(binDir, binaryName);
-
-    spinner.text = `📥 Descargando ${chalk.cyan(engineType)}...`;
-
-    // Download
-    await downloadFile(url, tempZipPath, (progress) => {
-        const percentage = progress.percentage.toFixed(1);
-        spinner.text = `📥 ${chalk.cyan(engineType)}: ${percentage}%`;
-    });
-
-    spinner.text = `📦 Extrayendo ${chalk.cyan(engineType)}...`;
-
-    // Extract
-    await extractBinary(tempZipPath, finalBinaryPath);
-
-    // Cleanup
-    cleanupFile(tempZipPath);
-
-    return finalBinaryPath;
-}
-
-function downloadFile(url, outputPath, onProgress) {
-    return new Promise((resolve, reject) => {
-        https.get(url, { timeout: 30000 }, (response) => {
-            // Handle redirects
-            if (response.statusCode === 302 || response.statusCode === 301) {
-                const redirectUrl = response.headers.location;
-                if (redirectUrl) {
-                    return downloadFile(redirectUrl, outputPath, onProgress).then(resolve).catch(reject);
-                }
-            }
-
-            if (response.statusCode !== 200) {
-                reject(new Error(`HTTP ${response.statusCode}: El binario no existe`));
-                return;
-            }
-
-            const file = fs.createWriteStream(outputPath);
-            const totalBytes = parseInt(response.headers['content-length'] || '0', 10);
-            let downloadedBytes = 0;
-
-            response.on('data', (chunk) => {
-                downloadedBytes += chunk.length;
-                file.write(chunk);
-
-                if (totalBytes > 0 && onProgress) {
-                    onProgress({
-                        downloaded: downloadedBytes,
-                        total: totalBytes,
-                        percentage: (downloadedBytes / totalBytes) * 100
-                    });
-                }
-            });
-
-            response.on('end', () => {
-                file.end();
-                resolve();
-            });
-
-            response.on('error', (err) => {
-                file.close();
-                cleanupFile(outputPath);
-                reject(err);
-            });
-
-            file.on('error', (err) => {
-                file.close();
-                cleanupFile(outputPath);
-                reject(err);
-            });
-        }).on('error', reject).on('timeout', () => {
-            reject(new Error('Timeout descargando el archivo'));
-        });
-    });
-}
-
-function extractBinary(zipPath, outputPath) {
-    return new Promise((resolve, reject) => {
-        let extracted = false;
-
-        fs.createReadStream(zipPath)
-            .pipe(unzipper.Parse())
-            .on('entry', (entry) => {
-                if (entry.type === 'File' && !extracted) {
-                    extracted = true;
-                    const writeStream = fs.createWriteStream(outputPath);
-
-                    entry.pipe(writeStream);
-
-                    writeStream.on('finish', () => {
-                        if (process.platform !== 'win32') {
-                            fs.chmodSync(outputPath, 0o755);
-                        }
-                        resolve();
-                    });
-
-                    writeStream.on('error', (err) => {
-                        reject(err);
-                    });
-                } else {
-                    entry.autodrain();
-                }
-            })
-            .on('error', (err) => {
-                reject(err);
-            })
-            .on('close', () => {
-                if (!extracted) {
-                    reject(new Error('No se encontró archivo válido en el ZIP'));
-                }
-            });
-    });
-}
-
-function cleanupFile(filePath) {
-    try {
-        if (fs.existsSync(filePath)) {
-            fs.unlinkSync(filePath);
-        }
-    } catch {
-        // Ignore cleanup errors
-    }
-}
-
-async function main() {
-    console.log(chalk.blue('\n🔄 Dbcube Upgrade - Actualización de Binarios\n'));
-
-    const spinner = ora('Iniciando proceso de actualización...').start();
-
-    try {
-        const binDir = getBinDir();
-
-        // Step 1: Clean bin directory
-        spinner.text = '🗑️  Limpiando directorio de binarios...';
-        const deletedCount = cleanBinDirectory(binDir);
-
-        if (deletedCount > 0) {
-            spinner.succeed(chalk.green(`✓ ${deletedCount} archivo(s) eliminado(s)`));
-        } else {
-            spinner.info(chalk.gray('No había binarios previos'));
-        }
-
-        // Step 2: Download all binaries
-        console.log(chalk.cyan('\n📦 Descargando binarios latest...\n'));
-
-        const results = [];
-        let successCount = 0;
-        let failCount = 0;
-
-        for (const binary of BINARIES) {
-            const binarySpinner = ora(`Procesando ${chalk.cyan(binary)}...`).start();
-
-            try {
-                const binaryPath = await downloadBinary(binary, 'latest', binarySpinner);
-                binarySpinner.succeed(chalk.green(`✓ ${binary} descargado`));
-                results.push({ binary, success: true, path: binaryPath });
-                successCount++;
-            } catch (error) {
-                binarySpinner.fail(chalk.red(`✗ ${binary} falló: ${error.message}`));
-                results.push({ binary, success: false, error: error.message });
-                failCount++;
-            }
-        }
-
-        // Summary
-        console.log(chalk.cyan('\n📊 Resumen de actualización:\n'));
-
-        for (const result of results) {
-            if (result.success) {
-                console.log(chalk.green(`  ✓ ${result.binary}`));
-                console.log(chalk.gray(`    ${result.path}`));
-            } else {
-                console.log(chalk.red(`  ✗ ${result.binary}`));
-                console.log(chalk.gray(`    Error: ${result.error}`));
-            }
-        }
-
-        console.log('');
-
-        if (failCount === 0) {
-            console.log(chalk.green.bold(`✅ Todos los binarios (${successCount}/${BINARIES.length}) actualizados exitosamente\n`));
-        } else if (successCount > 0) {
-            console.log(chalk.yellow.bold(`⚠️  Actualización parcial: ${successCount}/${BINARIES.length} binarios descargados\n`));
-            process.exit(1);
-        } else {
-            console.log(chalk.red.bold(`❌ No se pudo descargar ningún binario\n`));
-            process.exit(1);
-        }
-
-    } catch (error) {
-        spinner.fail(chalk.red('Error en el proceso de actualización'));
-        console.error(chalk.red(`\n❌ ${error.message}\n`));
-        process.exit(1);
-    }
-}
-
-main().catch(err => {
-    console.error(chalk.red('\n❌ Error inesperado:'), err.message);
-    process.exit(1);
-});