endform 0.48.0 → 0.48.2

package/bin/endform

@@ -9,7 +9,7 @@
 const child_process = require("node:child_process");
 const path = require("node:path");
 const fs = require("node:fs");
-const https = require("node:https");
+const { pipeline } = require("node:stream/promises");
 
 // Define supported platforms and architectures.
 const supportedPlatforms = ["darwin", "linux"];
@@ -72,48 +72,93 @@ const getDownloadInfo = () => {
   };
 };
 
-// Function to download the binary
-const downloadBinary = () => {
+const downloadBinary = async ({ force } = {}) => {
   const { url, binaryName } = getDownloadInfo();
   const currentDir = __dirname;
   const binaryPath = path.join(currentDir, binaryName);
 
+  // Fast path: binary already present.
+  if (!force && fs.existsSync(binaryPath)) return binaryPath;
+
   console.log(
     "Endform was not installed as an optional dependency, preparing on the fly...",
   );
 
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(binaryPath);
-    https
-      .get(url, (response) => {
-        if (response.statusCode !== 200) {
-          file.close();
-          fs.unlink(binaryPath, () => {});
-          reject(
-            new Error(
-              `Failed to download binary: ${response.statusCode} ${response.statusMessage}`,
-            ),
-          );
-          return;
-        }
-        response.pipe(file);
-        file.on("finish", () => {
-          file.close();
-          // Make the binary executable
-          fs.chmodSync(binaryPath, "755");
-          resolve(binaryPath);
-        });
-        file.on("error", (err) => {
-          fs.unlink(binaryPath, () => {});
-          reject(err);
-        });
-      })
-      .on("error", (err) => {
-        fs.unlink(binaryPath, () => {}); // Clean up binary file on error
-        console.error("Error downloading binary:", err);
-        reject(err);
-      });
-  });
+  const tmpPath = path.join(
+    currentDir,
+    `${binaryName}.${process.pid}.${Date.now()}.tmp`,
+  );
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download binary: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  if (!response.body) {
+    throw new Error("Failed to download binary: empty response body");
+  }
+
+  const file = fs.createWriteStream(tmpPath, { mode: 0o755 });
+  try {
+    await pipeline(response.body, file);
+  } finally {
+    // `pipeline` will close the stream on success/errors, but be defensive.
+    try {
+      file.close();
+    } catch {}
+  }
+
+  try {
+    fs.renameSync(tmpPath, binaryPath);
+    fs.chmodSync(binaryPath, 0o755);
+    return binaryPath;
+  } catch (err) {
+    fs.unlink(tmpPath, () => {});
+    throw err;
+  }
+};
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const isTextFileBusyError = (err) => {
+  if (!err) return false;
+  if (err.code === "ETXTBSY") return true;
+
+  // On some platforms Node may surface a numeric errno.
+  if (typeof err.errno === "number" && err.errno === -26) return true;
+  if (typeof err.message === "string" && err.message.includes("ETXTBSY")) {
+    return true;
+  }
+
+  return false;
+};
+
+const execFileSyncWithRetry = async (binaryPath, args, options) => {
+  const maxAttempts = 5;
+  let delayMs = 50;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      child_process.execFileSync(binaryPath, args, options);
+      return;
+    } catch (err) {
+      const shouldRetry = isTextFileBusyError(err) && attempt < maxAttempts;
+      if (!shouldRetry) throw err;
+
+      console.error(
+        `Endform binary was busy (ETXTBSY). Re-downloading and retrying (attempt ${attempt}/${maxAttempts})...`,
+      );
+
+      try {
+        await downloadBinary({ force: true });
+      } catch {}
+
+      await sleep(delayMs);
+      delayMs *= 2;
+    }
+  }
 };
 
 // Main execution function
@@ -129,11 +174,11 @@ const main = async () => {
       // If not found locally, try to resolve from installed optional dependency
       try {
         binaryPath = require.resolve(`${packageName}/${binaryRelativePath}`);
-      } catch (err) {
+      } catch (_err) {
         // If still not found, download the binary
         try {
           binaryPath = await downloadBinary();
-        } catch (err) {
+        } catch (_err) {
           console.error(
             `Error: Could not download the Endform binary for ${platform} (${arch}).`,
           );
@@ -144,10 +189,15 @@ const main = async () => {
 
     // Execute the binary and forward any command-line arguments.
     try {
-      child_process.execFileSync(binaryPath, process.argv.slice(2), {
+      await execFileSyncWithRetry(binaryPath, process.argv.slice(2), {
         stdio: "inherit",
       });
     } catch (err) {
+      // err.code is a string (e.g., "ENOENT") when the binary failed to execute,
+      // otherwise it's typically undefined (the CLI already printed its own error)
+      if (err.message && typeof err.code === "string") {
+        console.error(err.message);
+      }
       process.exit(err.status || 1);
     }
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "endform",
-  "version": "0.48.0",
+  "version": "0.48.2",
   "description": "Endform CLI",
   "repository": "https://github.com/endformdev/npm",
   "license": "UNLICENSED",
@@ -12,9 +12,9 @@
     "bin"
   ],
   "optionalDependencies": {
-    "endform-darwin-arm64": "0.48.0",
-    "endform-darwin-x86": "0.48.0",
-    "endform-linux-arm64": "0.48.0",
-    "endform-linux-x86": "0.48.0"
+    "endform-darwin-arm64": "0.48.2",
+    "endform-darwin-x86": "0.48.2",
+    "endform-linux-arm64": "0.48.2",
+    "endform-linux-x86": "0.48.2"
   }
 }