@yetech/estra7ah 3.3.1 → 3.3.3

package/dist/estra7ah.js

@@ -10,7 +10,9 @@ const RUNNERS = {
   win64: "runner-win-x64.exe",
   linux64: "runner-linux-x64",
   linuxarm64: "runner-linux-arm64",
-  linuxarmv7: "runner-linux-armv7",
+  // pkg has no node18 armv7 target, so 32-bit ARM (Raspberry Pi OS) gets the
+  // plain webpack bundle and runs it under the system Node instead.
+  linuxarmv7: "runner.js",
 };
 const DIR_NAME = __dirname;
 
@@ -51,17 +53,46 @@ function downloadRange(url, fd, start, end, progressBar, attempt = 0) {
     .then(
       (response) =>
         new Promise((resolve, reject) => {
+          // A 200 means the server (or a proxy on this plain-HTTP route) ignored
+          // the Range header and is sending the whole file: writing that at six
+          // different offsets corrupts the binary. Bail out to single-stream.
+          if (response.status !== 206) {
+            response.data.destroy();
+            return reject({ noRangeSupport: true });
+          }
           let position = start;
+          // With timeout: 0 a dead connection would hang the update forever
+          // (progress stuck at 0%). Kill the stream if no data arrives for 30s
+          // so the retry/fallback path can take over.
+          let watchdog;
+          const resetWatchdog = () => {
+            clearTimeout(watchdog);
+            watchdog = setTimeout(() => {
+              response.data.destroy(new Error("download stalled: no data for 30s"));
+            }, 30000);
+          };
+          resetWatchdog();
+          response.data.on("close", () => clearTimeout(watchdog));
           response.data.on("data", (chunk) => {
+            resetWatchdog();
             fs.writeSync(fd, chunk, 0, chunk.length, position);
             position += chunk.length;
             progressBar.tick(chunk.length);
           });
-          response.data.on("end", () => resolve(position));
+          response.data.on("end", () => {
+            // "end" also fires on some premature disconnects; an incomplete
+            // chunk must be retried, never treated as success.
+            if (position !== end + 1) {
+              return reject({ err: new Error(`chunk ended at ${position}, expected ${end + 1}`), position });
+            }
+            resolve(position);
+          });
+          response.data.on("aborted", () => reject({ err: new Error("connection aborted"), position }));
           response.data.on("error", (err) => reject({ err, position }));
         })
     )
     .catch((failure) => {
+      if (failure && failure.noRangeSupport) throw failure;
       const resumeAt = failure.position || start;
       if (attempt < 2) return downloadRange(url, fd, resumeAt, end, progressBar, attempt + 1);
       throw failure.err || failure;
@@ -103,10 +134,17 @@ async function downloadFileFast(url, destPath) {
     await Promise.all(jobs);
   } catch (error) {
     fs.closeSync(fd);
-    fs.unlinkSync(tmpPath);
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch (e) {}
+    if (error && error.noRangeSupport) return downloadFileStream(url, destPath);
     throw error;
   }
   fs.closeSync(fd);
+  if (fs.statSync(tmpPath).size !== totalLength) {
+    fs.unlinkSync(tmpPath);
+    throw new Error("downloaded size does not match content-length");
+  }
   fs.renameSync(tmpPath, destPath);
 }
 
@@ -121,12 +159,40 @@ function downloadFileStream(url, destPath) {
           total: totalLength,
         })
       : null;
-    const writer = fs.createWriteStream(destPath);
+    const tmpPath = `${destPath}.download`;
+    const writer = fs.createWriteStream(tmpPath);
     return new Promise((resolve, reject) => {
-      if (progressBar) response.data.on("data", (chunk) => progressBar.tick(chunk.length));
-      writer.on("error", reject);
-      writer.on("finish", resolve);
-      response.data.on("error", reject);
+      let watchdog;
+      const fail = (err) => {
+        clearTimeout(watchdog);
+        writer.destroy();
+        try {
+          fs.unlinkSync(tmpPath);
+        } catch (e) {}
+        reject(err);
+      };
+      const resetWatchdog = () => {
+        clearTimeout(watchdog);
+        watchdog = setTimeout(() => {
+          response.data.destroy(new Error("download stalled: no data for 30s"));
+        }, 30000);
+      };
+      resetWatchdog();
+      response.data.on("data", (chunk) => {
+        resetWatchdog();
+        if (progressBar) progressBar.tick(chunk.length);
+      });
+      writer.on("error", fail);
+      writer.on("finish", () => {
+        clearTimeout(watchdog);
+        if (totalLength && fs.statSync(tmpPath).size !== totalLength) {
+          return fail(new Error("downloaded size does not match content-length"));
+        }
+        fs.renameSync(tmpPath, destPath);
+        resolve();
+      });
+      response.data.on("aborted", () => fail(new Error("connection aborted")));
+      response.data.on("error", fail);
       response.data.pipe(writer);
     });
   });
@@ -150,13 +216,18 @@ async function downloadRunner() {
     localVersion = fs.readFileSync(versionFilePath, "utf-8");
   }
 
-  if (localVersion !== version) {
+  if (localVersion !== version || !fs.existsSync(`${DIR_NAME}/${getRunner()}`)) {
     console.log("** DOWNLOADING NEW RUNNER VERSION **");
     const serverFile = `${YETECH_URL}/runner/${getRunner()}`;
     const runnerPath = `${DIR_NAME}/${getRunner()}`;
 
     try {
-      await downloadFileFast(serverFile, runnerPath);
+      try {
+        await downloadFileFast(serverFile, runnerPath);
+      } catch (error) {
+        console.error("Parallel download failed, retrying with a single stream:", error.message);
+        await downloadFileStream(serverFile, runnerPath);
+      }
       fs.writeFileSync(versionFilePath, version);
       console.log("** Finished DOWNLOADING NEW RUNNER VERSION **");
     } catch (error) {
@@ -167,20 +238,24 @@ async function downloadRunner() {
 
 // Start the runner executable
 function startRunner() {
-  const runnerPath = `"${DIR_NAME}/${getRunner()}"`;
+  const runnerFile = getRunner();
+  const runnerPath = `"${DIR_NAME}/${runnerFile}"`;
   const args = process.argv.slice(2);
   const options = { stdio: "inherit", shell: true };
 
   setTimeout(() => {
     if (process.platform !== "win32") {
       try {
-        fs.chmodSync(`${DIR_NAME}/${getRunner()}`, "755");
+        fs.chmodSync(`${DIR_NAME}/${runnerFile}`, "755");
       } catch (error) {
         console.error("Error setting permissions:", error.message);
       }
     }
 
-    const runnerProcess = child_process.spawn(runnerPath, args, options);
+    // .js runner (armv7) runs under the same Node that launched us
+    const command = runnerFile.endsWith(".js") ? `"${process.execPath}"` : runnerPath;
+    const commandArgs = runnerFile.endsWith(".js") ? [runnerPath, ...args] : args;
+    const runnerProcess = child_process.spawn(command, commandArgs, options);
     runnerProcess.on("exit", (code) => {
       console.log(`Runner exited with code ${code}`);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yetech/estra7ah",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "description": "Estra7ah Manager",
   "author": "Abdullah Al-taheri",
   "keywords": [