satoridb 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "satoridb",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Install satori",
   "bin" : {
     "satori" : "cli.js"

package/postinstall.js

@@ -15,63 +15,160 @@ if (platform === "linux") fileName = "lin/satori-linux.zip";
 else if (platform === "darwin") fileName = "mac/satori-mac.zip";
 else if (platform === "win32") fileName = "win/satori-win.zip";
 else {
-  console.error("❌ Plataforma no soportada:", platform);
+  console.error("❌ Not supported platform:", platform);
   process.exit(1);
 }
 
 const tmpDir = path.join(os.tmpdir(), "satori-temp");
-fs.mkdirSync(tmpDir, { recursive: true });
-
 const zipPath = path.join(tmpDir, fileName);
 const installDir = path.join(os.homedir(), ".satori", "bin");
 const binName = platform === "win32" ? "satori.exe" : "satori";
 const binFullPath = path.join(installDir, binName);
 
-// Descargar ZIP
+console.log(`📁 Temp directory: ${tmpDir}`);
+console.log(`📁 Install directory: ${installDir}`);
+console.log(`📁 Zip path: ${zipPath}`);
+
+// Crear directorio temporal y subdirectorios con mejor manejo de errores
+try {
+  fs.mkdirSync(tmpDir, { recursive: true });
+  console.log(`✅ Temp directory created/verified`);
+  
+  // Crear el subdirectorio específico de la plataforma si es necesario
+  const platformSubDir = path.dirname(zipPath);
+  if (platformSubDir !== tmpDir) {
+    fs.mkdirSync(platformSubDir, { recursive: true });
+    console.log(`✅ Platform subdirectory created: ${platformSubDir}`);
+  }
+} catch (err) {
+  console.error("❌ Error creating directories:", err.message);
+  process.exit(1);
+}
+
+// Descargar ZIP con mejor manejo de errores
 function downloadZip(url, dest, cb) {
+  console.log(`🔽 Downloading from: ${url}`);
+  
   const file = fs.createWriteStream(dest);
-  https.get(url, response => {
+  
+  const request = https.get(url, response => {
+    console.log(`📡 Response status: ${response.statusCode}`);
+    
     if (response.statusCode !== 200) {
-      console.error("❌ Fallo al descargar el binario:", response.statusCode);
+      console.error("❌ Download failed:", response.statusCode);
+      file.close();
+      fs.unlink(dest, () => {}); // Limpiar archivo parcial
       process.exit(1);
     }
 
     response.pipe(file);
+    
     file.on("finish", () => {
-      file.close(cb);
+      file.close(() => {
+        console.log(`✅ Download completed: ${dest}`);
+        // Verificar que el archivo existe y tiene contenido
+        try {
+          const stats = fs.statSync(dest);
+          console.log(`📊 File size: ${stats.size} bytes`);
+          if (stats.size === 0) {
+            console.error("❌ Downloaded file is empty");
+            fs.unlink(dest, () => {});
+            process.exit(1);
+          }
+          cb();
+        } catch (err) {
+          console.error("❌ Error verifying downloaded file:", err.message);
+          process.exit(1);
+        }
+      });
     });
-  }).on('error', err => {
-    console.error("❌ Error de red:", err.message);
+    
+    file.on("error", err => {
+      console.error("❌ Error writing file:", err.message);
+      fs.unlink(dest, () => {});
+      process.exit(1);
+    });
+  });
+  
+  request.on('error', err => {
+    console.error("❌ Network error:", err.message);
+    file.close();
+    fs.unlink(dest, () => {});
+    process.exit(1);
+  });
+  
+  request.setTimeout(30000, () => {
+    console.error("❌ Download timeout");
+    request.destroy();
+    file.close();
+    fs.unlink(dest, () => {});
     process.exit(1);
   });
 }
 
-// Extraer ZIP
+// Extraer ZIP con mejor manejo de errores
 function extractZip(src, dest) {
+  console.log(`📦 Extracting from: ${src}`);
+  console.log(`📦 Extracting to: ${dest}`);
+  
   try {
+    // Verificar que el archivo ZIP existe
+    if (!fs.existsSync(src)) {
+      console.error(`❌ ZIP file not found: ${src}`);
+      process.exit(1);
+    }
+    
     const zip = new AdmZip(src);
     zip.extractAllTo(dest, true);
-    if (platform !== "win32") chmodSync(path.join(dest, binName), 0o755);
+    
+    // Verificar que el binario fue extraído
+    const binPath = path.join(dest, binName);
+    if (!fs.existsSync(binPath)) {
+      console.error(`❌ Binary not found after extraction: ${binPath}`);
+      process.exit(1);
+    }
+    
+    if (platform !== "win32") {
+      chmodSync(binPath, 0o755);
+      console.log(`✅ Set executable permissions on: ${binPath}`);
+    }
+    
+    console.log(`✅ Extraction completed`);
   } catch (err) {
-    console.error("❌ Error al extraer el zip:", err.message);
+    console.error("❌ Error extracting zip:", err.message);
     process.exit(1);
   }
 }
 
 // Ejecutar
-console.log(`🔽 Descargando Satori para ${platform}/${arch}...`);
+console.log(`🔽 Downloading Satori ${platform}/${arch}...`);
 
 downloadZip(`${baseURL}/${fileName}`, zipPath, () => {
-  fs.mkdirSync(installDir, { recursive: true });
+  try {
+    fs.mkdirSync(installDir, { recursive: true });
+    console.log(`✅ Install directory created/verified`);
+  } catch (err) {
+    console.error("❌ Error creating install directory:", err.message);
+    process.exit(1);
+  }
+  
   extractZip(zipPath, installDir);
-  console.log(`✅ Binario instalado en: ${binFullPath}\n`);
+  console.log(`✅ Binary installed in: ${binFullPath}\n`);
+
+  // Limpiar archivo temporal
+  try {
+    fs.unlinkSync(zipPath);
+    console.log(`🧹 Cleaned up temporary file: ${zipPath}`);
+  } catch (err) {
+    console.warn(`⚠️ Could not clean up temporary file: ${err.message}`);
+  }
 
   const shell = process.env.SHELL || "";
   const profileFile = shell.includes("zsh") ? ".zshrc" : ".bashrc";
 
   const exportLine = `export PATH="$HOME/.satori/bin:$PATH"`;
 
-  console.log(`💡 Añade esto a tu ~/${profileFile}:\n`);
+  console.log(`💡 Add this to your ~/${profileFile}:\n`);
   console.log(`  ${exportLine}\n`);
-  console.log(`Luego ejecuta: source ~/${profileFile}\n`);
+  console.log(`Then run: source ~/${profileFile}\n`);
 });