@yetech/estra7ah 3.3.3 → 3.3.5

package/dist/estra7ah.js

@@ -1,11 +1,24 @@
 #!/usr/bin/env node
 
+// Never let a stray async error kill the launcher: PM2 would restart it and
+// spawn a second runner while the orphaned one still holds the ports.
+process.on("uncaughtException", (err) => {
+  console.error("Unexpected error:", err && err.message ? err.message : err);
+});
+
 const axios = require("axios");
 const fs = require("fs");
 const ProgressBar = require("progress");
 const child_process = require("child_process");
 
 const YETECH_URL = `http://premium.yetech.co:80`;
+// Cloudflare-cached mirror of /runner/* (origin = same VPS). Plain HTTP on
+// purpose: the origin is HTTP-only, and download integrity is enforced by the
+// content-length size check, so TLS to the edge buys nothing here while
+// avoiding the origin-cert / SSL-mode requirement. The ?v= query string busts
+// the edge cache exactly when a new build lands, so stale binaries are
+// impossible and no cache purging is ever needed.
+const CDN_URL = `http://dl.yetech.co`;
 const RUNNERS = {
   win64: "runner-win-x64.exe",
   linux64: "runner-linux-x64",
@@ -42,7 +55,10 @@ function getRunner() {
 // pulling the binary over several range requests at once is ~N times faster.
 const PARALLEL_CHUNKS = 6;
 
-function downloadRange(url, fd, start, end, progressBar, attempt = 0) {
+// ctx = { fd, closed, streams } shared by all chunks of one download, so a
+// failed download can cancel its siblings before the fd is closed — otherwise
+// their in-flight writes land on a closed (or reused) descriptor.
+function downloadRange(url, ctx, start, end, progressBar, attempt = 0) {
   return axios({
     method: "get",
     url,
@@ -53,18 +69,31 @@ function downloadRange(url, fd, start, end, progressBar, attempt = 0) {
     .then(
       (response) =>
         new Promise((resolve, reject) => {
+          let watchdog;
+          let settled = false;
+          const done = (fn, value) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(watchdog);
+            ctx.streams.delete(response.data);
+            fn(value);
+          };
+          if (ctx.closed) {
+            response.data.destroy();
+            return done(reject, { err: new Error("download cancelled") });
+          }
+          ctx.streams.add(response.data);
           // 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 });
+            return done(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(() => {
@@ -74,8 +103,17 @@ function downloadRange(url, fd, start, end, progressBar, attempt = 0) {
           resetWatchdog();
           response.data.on("close", () => clearTimeout(watchdog));
           response.data.on("data", (chunk) => {
+            if (settled || ctx.closed) {
+              response.data.destroy();
+              return;
+            }
             resetWatchdog();
-            fs.writeSync(fd, chunk, 0, chunk.length, position);
+            try {
+              fs.writeSync(ctx.fd, chunk, 0, chunk.length, position);
+            } catch (err) {
+              response.data.destroy(err);
+              return;
+            }
             position += chunk.length;
             progressBar.tick(chunk.length);
           });
@@ -83,18 +121,19 @@ function downloadRange(url, fd, start, end, progressBar, attempt = 0) {
             // "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 });
+              return done(reject, { err: new Error(`chunk ended at ${position}, expected ${end + 1}`), position });
             }
-            resolve(position);
+            done(resolve, position);
           });
-          response.data.on("aborted", () => reject({ err: new Error("connection aborted"), position }));
-          response.data.on("error", (err) => reject({ err, position }));
+          response.data.on("aborted", () => done(reject, { err: new Error("connection aborted"), position }));
+          response.data.on("error", (err) => done(reject, { err, position }));
         })
     )
     .catch((failure) => {
       if (failure && failure.noRangeSupport) throw failure;
+      if (ctx.closed) throw failure.err || failure;
       const resumeAt = failure.position || start;
-      if (attempt < 2) return downloadRange(url, fd, resumeAt, end, progressBar, attempt + 1);
+      if (attempt < 2) return downloadRange(url, ctx, resumeAt, end, progressBar, attempt + 1);
       throw failure.err || failure;
     });
 }
@@ -122,27 +161,40 @@ async function downloadFileFast(url, destPath) {
   // Download to a temp file so a failed/interrupted update never corrupts
   // the runner binary we already have.
   const tmpPath = `${destPath}.download`;
-  const fd = fs.openSync(tmpPath, "w");
+  const ctx = { fd: fs.openSync(tmpPath, "w"), closed: false, streams: new Set() };
   try {
-    fs.ftruncateSync(fd, totalLength);
+    fs.ftruncateSync(ctx.fd, totalLength);
     const chunkSize = Math.ceil(totalLength / PARALLEL_CHUNKS);
     const jobs = [];
     for (let start = 0; start < totalLength; start += chunkSize) {
       const end = Math.min(start + chunkSize - 1, totalLength - 1);
-      jobs.push(downloadRange(url, fd, start, end, progressBar));
+      jobs.push(downloadRange(url, ctx, start, end, progressBar));
     }
     await Promise.all(jobs);
   } catch (error) {
-    fs.closeSync(fd);
+    ctx.closed = true;
+    ctx.streams.forEach((stream) => {
+      try {
+        stream.destroy();
+      } catch (e) {}
+    });
+    try {
+      fs.closeSync(ctx.fd);
+    } catch (e) {}
     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);
+  ctx.closed = true;
+  try {
+    fs.closeSync(ctx.fd);
+  } catch (e) {}
+  if (!fs.existsSync(tmpPath) || fs.statSync(tmpPath).size !== totalLength) {
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch (e) {}
     throw new Error("downloaded size does not match content-length");
   }
   fs.renameSync(tmpPath, destPath);
@@ -163,9 +215,20 @@ function downloadFileStream(url, destPath) {
     const writer = fs.createWriteStream(tmpPath);
     return new Promise((resolve, reject) => {
       let watchdog;
+      // fail() and finish can race (e.g. watchdog fires while the writer is
+      // flushing); whichever settles first wins, the other becomes a no-op —
+      // and no fs call in here may throw, or it crashes the whole process.
+      let settled = false;
       const fail = (err) => {
+        if (settled) return;
+        settled = true;
         clearTimeout(watchdog);
-        writer.destroy();
+        try {
+          response.data.destroy();
+        } catch (e) {}
+        try {
+          writer.destroy();
+        } catch (e) {}
         try {
           fs.unlinkSync(tmpPath);
         } catch (e) {}
@@ -173,9 +236,7 @@ function downloadFileStream(url, destPath) {
       };
       const resetWatchdog = () => {
         clearTimeout(watchdog);
-        watchdog = setTimeout(() => {
-          response.data.destroy(new Error("download stalled: no data for 30s"));
-        }, 30000);
+        watchdog = setTimeout(() => fail(new Error("download stalled: no data for 30s")), 30000);
       };
       resetWatchdog();
       response.data.on("data", (chunk) => {
@@ -184,11 +245,21 @@ function downloadFileStream(url, destPath) {
       });
       writer.on("error", fail);
       writer.on("finish", () => {
+        if (settled) return;
+        settled = true;
         clearTimeout(watchdog);
-        if (totalLength && fs.statSync(tmpPath).size !== totalLength) {
-          return fail(new Error("downloaded size does not match content-length"));
+        try {
+          if (!fs.existsSync(tmpPath)) throw new Error("temp download file disappeared");
+          if (totalLength && fs.statSync(tmpPath).size !== totalLength) {
+            throw new Error("downloaded size does not match content-length");
+          }
+          fs.renameSync(tmpPath, destPath);
+        } catch (err) {
+          try {
+            fs.unlinkSync(tmpPath);
+          } catch (e) {}
+          return reject(err);
         }
-        fs.renameSync(tmpPath, destPath);
         resolve();
       });
       response.data.on("aborted", () => fail(new Error("connection aborted")));
@@ -218,21 +289,32 @@ async function downloadRunner() {
 
   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()}`;
+    // CDN first (version is always fetched from the origin, so a fresh version
+    // always maps to a fresh cache key); fall back to the VPS if the CDN fails.
+    const sources = [
+      `${CDN_URL}/runner/${getRunner()}?v=${encodeURIComponent(version)}`,
+      `${YETECH_URL}/runner/${getRunner()}`,
+    ];
 
-    try {
+    let lastError = null;
+    for (const serverFile of sources) {
       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 **");
+        return;
       } catch (error) {
-        console.error("Parallel download failed, retrying with a single stream:", error.message);
-        await downloadFileStream(serverFile, runnerPath);
+        lastError = error;
+        console.error("Download failed from " + serverFile.split("?")[0] + " :", error.message);
       }
-      fs.writeFileSync(versionFilePath, version);
-      console.log("** Finished DOWNLOADING NEW RUNNER VERSION **");
-    } catch (error) {
-      console.error("Error downloading runner:", error.message);
     }
+    console.error("Error downloading runner:", lastError ? lastError.message : "all sources failed");
   }
 }
 

package/package.json

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