@dbcube/core 1.0.28 → 1.0.32

package/dist/index.cjs

@@ -173,7 +173,11 @@ var path = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 var import_follow_redirects = require("follow-redirects");
 var unzipper = __toESM(require("unzipper"));
+var import_ora = __toESM(require("ora"));
+var import_chalk = __toESM(require("chalk"));
 var Downloader = class {
+  static mainSpinner = null;
+  static currentSpinner = null;
   static get(prefix) {
     const arch2 = new Arquitecture();
     const platform2 = arch2.getPlatform();
@@ -211,12 +215,16 @@ var Downloader = class {
     const binaries = ["schema", "query", "sqlite"];
     const binDir = targetDir || this.getDefaultBinDir();
     fs.mkdirSync(binDir, { recursive: true });
-    for (const prefix of binaries) {
+    this.mainSpinner = (0, import_ora.default)({
+      text: import_chalk.default.blue("Descargando binarios necesarios..."),
+      spinner: "dots12"
+    }).start();
+    for (let i = 0; i < binaries.length; i++) {
+      const prefix = binaries[i];
       const maxRetries = 3;
       let attempt = 0;
       while (attempt <= maxRetries) {
         try {
-          console.log(`\u{1F4E5} Descargando ${prefix} (intento ${attempt + 1}/${maxRetries + 1})...`);
           const binaryInfo = this.get(prefix);
           if (!binaryInfo.name || !binaryInfo.url) {
             throw new Error("Plataforma o arquitectura no soportada");
@@ -224,35 +232,65 @@ var Downloader = class {
           const tempZipPath = path.join(os2.tmpdir(), `dbcube-${prefix}-${Date.now()}.zip`);
           const finalBinaryPath = path.join(binDir, binaryInfo.name);
           if (fs.existsSync(finalBinaryPath)) {
-            console.log(`\u2705 ${prefix} ya existe, omitiendo`);
+            this.updateMainProgress(prefix, i + 1, binaries.length, "exists");
             break;
           }
-          await this.downloadFile(binaryInfo.url, tempZipPath, prefix);
+          this.updateMainProgress(prefix, i + 1, binaries.length, "downloading");
+          await this.downloadFileWithProgress(binaryInfo.url, tempZipPath, prefix);
+          this.updateMainProgress(prefix, i + 1, binaries.length, "extracting");
           await this.extractBinary(tempZipPath, finalBinaryPath, prefix);
-          console.log(`\u2705 ${prefix} descargado correctamente`);
+          this.updateMainProgress(prefix, i + 1, binaries.length, "completed");
           break;
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : "Error desconocido";
           if (attempt < maxRetries && (errorMessage.includes("ECONNRESET") || errorMessage.includes("timeout") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("ENOTFOUND"))) {
-            console.warn(`\u26A0\uFE0F  Error de red para ${prefix}: ${errorMessage}`);
-            console.log(`\u{1F504} Reintentando en 3 segundos...`);
             attempt++;
-            await new Promise((resolve5) => setTimeout(resolve5, 3e3));
+            this.updateMainProgress(prefix, i + 1, binaries.length, "retrying", attempt);
+            await new Promise((resolve5) => setTimeout(resolve5, 2e3));
           } else {
-            console.error(`\u274C Error final descargando ${prefix}:`, errorMessage);
+            this.mainSpinner.fail(import_chalk.default.red(`Error descargando ${prefix}: ${errorMessage}`));
             throw error;
           }
         }
       }
     }
-  }
-  static downloadFile(url, outputPath, prefix) {
+    this.mainSpinner.succeed(import_chalk.default.green("Binarios descargados correctamente"));
+  }
+  static updateMainProgress(binary, current, total, status, attempt) {
+    const progressBar = this.createProgressBar(current, total);
+    const statusEmojis = {
+      downloading: "\u{1F4E5}",
+      extracting: "\u{1F4E6}",
+      completed: "\u2705",
+      exists: "\u2705",
+      retrying: "\u{1F504}"
+    };
+    const statusMessages = {
+      downloading: import_chalk.default.blue("descargando"),
+      extracting: import_chalk.default.yellow("extrayendo"),
+      completed: import_chalk.default.green("completado"),
+      exists: import_chalk.default.gray("existe"),
+      retrying: import_chalk.default.orange(`reintentando (${attempt}/${3})`)
+    };
+    const emoji = statusEmojis[status] || "\u{1F4E5}";
+    const message = statusMessages[status] || status;
+    this.mainSpinner.text = `${progressBar} ${emoji} ${import_chalk.default.bold(binary)} - ${message}`;
+  }
+  static createProgressBar(current, total, width = 20) {
+    const filled = Math.round(current / total * width);
+    const empty = width - filled;
+    const filledBar = import_chalk.default.green("\u2588".repeat(filled));
+    const emptyBar = import_chalk.default.gray("\u2591".repeat(empty));
+    const percentage = import_chalk.default.bold(`${current}/${total}`);
+    return `[${filledBar}${emptyBar}] ${percentage}`;
+  }
+  static downloadFileWithProgress(url, outputPath, prefix) {
     return new Promise((resolve5, reject) => {
       const request = import_follow_redirects.https.get(url, { timeout: 6e4 }, (response) => {
         if (response.statusCode === 302 || response.statusCode === 301) {
           const redirectUrl = response.headers.location;
           if (redirectUrl) {
-            return this.downloadFile(redirectUrl, outputPath, prefix).then(resolve5).catch(reject);
+            return this.downloadFileWithProgress(redirectUrl, outputPath, prefix).then(resolve5).catch(reject);
           }
         }
         if (response.statusCode !== 200) {
@@ -262,21 +300,20 @@ var Downloader = class {
         const file = fs.createWriteStream(outputPath);
         const totalBytes = parseInt(response.headers["content-length"] || "0", 10);
         let downloadedBytes = 0;
-        if (totalBytes > 0) {
-          console.log(`\u{1F4E6} Descargando ${(totalBytes / 1024 / 1024).toFixed(1)}MB...`);
-        }
         response.on("data", (chunk) => {
           downloadedBytes += chunk.length;
           file.write(chunk);
           if (totalBytes > 0) {
-            const progress = (downloadedBytes / totalBytes * 100).toFixed(1);
-            process.stdout.write(`\r\u23F3 Progreso: ${progress}%`);
+            const progress = {
+              downloaded: downloadedBytes,
+              total: totalBytes,
+              percentage: downloadedBytes / totalBytes * 100
+            };
+            this.updateDownloadProgress(prefix, progress);
           }
         });
         response.on("end", () => {
           file.end();
-          console.log(`
-\u2705 Descarga de ${prefix} completada`);
           resolve5();
         });
         response.on("error", (err) => {
@@ -297,6 +334,17 @@ var Downloader = class {
       });
     });
   }
+  static updateDownloadProgress(binary, progress) {
+    const percentage = progress.percentage.toFixed(1);
+    const downloaded = (progress.downloaded / 1024 / 1024).toFixed(1);
+    const total = (progress.total / 1024 / 1024).toFixed(1);
+    const barWidth = 15;
+    const filled = Math.round(progress.percentage / 100 * barWidth);
+    const empty = barWidth - filled;
+    const progressBar = import_chalk.default.green("\u2588".repeat(filled)) + import_chalk.default.gray("\u2591".repeat(empty));
+    const progressText = `[${progressBar}] ${percentage}% (${downloaded}/${total}MB)`;
+    this.mainSpinner.text = `\u{1F4E5} ${import_chalk.default.bold(binary)} - ${progressText}`;
+  }
   static extractBinary(zipPath, outputPath, prefix) {
     return new Promise((resolve5, reject) => {
       let extracted = false;
@@ -310,7 +358,6 @@ var Downloader = class {
               fs.chmodSync(outputPath, 493);
             }
             this.cleanupFile(zipPath);
-            console.log(`\u{1F4C1} ${prefix} extra\xEDdo correctamente`);
             resolve5();
           });
           writeStream.on("error", (err) => {
@@ -341,7 +388,7 @@ var Downloader = class {
   }
   static getDefaultBinDir() {
     const possibleDirs = [
-      path.resolve(process.cwd(), "bin"),
+      path.resolve(process.cwd(), ".dbcube", "bin"),
       path.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
       path.resolve(__dirname, "..", "bin")
     ];
@@ -358,7 +405,7 @@ var Downloader = class {
         continue;
       }
     }
-    const tempDir = path.join(os2.tmpdir(), "dbcube-bin");
+    const tempDir = path.join(os2.tmpdir(), ".dbcube", "bin");
     fs.mkdirSync(tempDir, { recursive: true });
     return tempDir;
   }
@@ -367,6 +414,7 @@ var Downloader = class {
 // src/lib/Binary.ts
 var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
 var Binary = class {
   static isDownloading = false;
   static downloadPromise = null;
@@ -398,11 +446,9 @@ var Binary = class {
     }
   }
   static async downloadBinaries() {
-    console.log("\u{1F680} DBCube: Descargando binarios necesarios...");
     try {
       const binDir = this.getBinDir();
       await Downloader.download(binDir);
-      console.log("\u2705 DBCube: Binarios descargados correctamente");
     } catch (error) {
       console.warn("\u26A0\uFE0F DBCube: Error descargando binarios:", error.message);
       console.log("\u{1F527} Los binarios se intentar\xE1n descargar en la pr\xF3xima ejecuci\xF3n");
@@ -410,7 +456,7 @@ var Binary = class {
   }
   static getBinDir() {
     const possibleDirs = [
-      path2.resolve(process.cwd(), "bin"),
+      path2.resolve(process.cwd(), ".dbcube", "bin"),
       path2.resolve(process.cwd(), "node_modules", ".dbcube", "bin"),
       path2.resolve(__dirname, "..", "bin")
     ];
@@ -419,12 +465,32 @@ var Binary = class {
         if (!fs2.existsSync(dir)) {
           fs2.mkdirSync(dir, { recursive: true });
         }
+        if (dir.includes(path2.resolve(process.cwd(), ".dbcube"))) {
+          this.ensureGitIgnore(path2.resolve(process.cwd(), ".dbcube"));
+        }
         return dir;
       } catch {
         continue;
       }
     }
-    return process.cwd();
+    const tempDir = path2.join(os3.tmpdir(), ".dbcube", "bin");
+    fs2.mkdirSync(tempDir, { recursive: true });
+    return tempDir;
+  }
+  static ensureGitIgnore(dbcubeDir) {
+    try {
+      const gitignorePath = path2.join(dbcubeDir, ".gitignore");
+      if (!fs2.existsSync(gitignorePath)) {
+        const gitignoreContent = `# DBCube binaries
+bin/
+*.exe
+*.log
+*.tmp
+`;
+        fs2.writeFileSync(gitignorePath, gitignoreContent);
+      }
+    } catch {
+    }
   }
   static async get() {
     await this.ensureBinariesExist();