@paulnsorensen/tilth-nightly 0.0.0-experimental.0 → 0.0.0-experimental.100.1

package/install.js

@@ -5,6 +5,7 @@
 const https = require("https");
 const fs = require("fs");
 const path = require("path");
+const crypto = require("crypto");
 const { execSync } = require("child_process");
 
 const PLATFORM_MAP = {
@@ -41,10 +42,24 @@ fs.mkdirSync(binDir, { recursive: true });
 console.log(`tilth: downloading ${target} nightly binary...`);
 
 const MAX_REDIRECTS = 5;
+const MAX_ATTEMPTS = 4;
+const RETRY_BACKOFF_MS = [1000, 2000, 4000];
+
+function isRetryableStatus(code) {
+  return code === 429 || code === 404 || (code >= 500 && code < 600);
+}
+
+function retryDownload(url, depth, callback, attempt, reason) {
+  const delayMs = RETRY_BACKOFF_MS[attempt - 1];
+  console.error(
+    `tilth: download failed (${reason}), retry ${attempt}/${MAX_ATTEMPTS - 1} in ${delayMs / 1000}s`,
+  );
+  setTimeout(() => follow(url, depth, callback, attempt + 1), delayMs);
+}
 
 // HTTPS-only, depth-capped: this binary is executed after download, so never
 // let a redirect downgrade to plaintext or loop.
-function follow(url, depth, callback) {
+function follow(url, depth, callback, attempt = 1) {
   if (!url.startsWith("https:")) {
     console.error(`tilth: refusing non-HTTPS download URL: ${url}`);
     process.exit(1);
@@ -53,9 +68,14 @@ function follow(url, depth, callback) {
     console.error(`tilth: too many redirects (>${MAX_REDIRECTS})`);
     process.exit(1);
   }
-  https.get(url, { headers: { "User-Agent": "tilth-npm" } }, (res) => {
+  const req = https.get(url, { headers: { "User-Agent": "tilth-npm" } }, (res) => {
     if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-      follow(res.headers.location, depth + 1, callback);
+      res.resume();
+      // Location may be relative; resolve against the current URL before recursing.
+      follow(new URL(res.headers.location, url).href, depth + 1, callback, attempt);
+    } else if (isRetryableStatus(res.statusCode) && attempt < MAX_ATTEMPTS) {
+      res.resume();
+      retryDownload(url, depth, callback, attempt, `HTTP ${res.statusCode}`);
     } else if (res.statusCode !== 200) {
       console.error(`tilth: download failed (HTTP ${res.statusCode})`);
       console.error(`URL: ${url}`);
@@ -64,33 +84,65 @@ function follow(url, depth, callback) {
     } else {
       callback(res);
     }
-  }).on("error", (err) => {
+  });
+  req.on("error", (err) => {
+    if (attempt < MAX_ATTEMPTS) {
+      retryDownload(url, depth, callback, attempt, err.message);
+      return;
+    }
     console.error(`tilth: download failed: ${err.message}`);
     console.error("Install manually: cargo install --git https://github.com/paulnsorensen/tilth");
     process.exit(1);
   });
+  req.setTimeout(30000, () => {
+    req.destroy(new Error("timeout after 30s"));
+  });
+}
+
+function buffer(res, callback) {
+  const chunks = [];
+  res.on("data", (chunk) => chunks.push(chunk));
+  res.on("end", () => callback(Buffer.concat(chunks)));
+  res.on("error", (err) => {
+    console.error(`tilth: download failed: ${err.message}`);
+    console.error("Install manually: cargo install --git https://github.com/paulnsorensen/tilth");
+    process.exit(1);
+  });
+}
+
+function parseChecksum(text, sidecarUrl) {
+  const match = /^([0-9a-fA-F]{64})\s/.exec(text);
+  if (!match) {
+    console.error(`tilth: malformed checksum sidecar at ${sidecarUrl}`);
+    console.error("Install manually: cargo install --git https://github.com/paulnsorensen/tilth");
+    process.exit(1);
+  }
+  return match[1].toLowerCase();
 }
 
-follow(url, 0, (res) => {
+function extract(buf) {
   if (isWindows) {
+    // Extract with PowerShell's Expand-Archive, not `tar`: the `tar` resolved on
+    // a Windows PATH may be GNU tar (shipped by Git for Windows), which cannot
+    // read the zip format and fails. Expand-Archive is built into Windows
+    // PowerShell and handles zip natively.
     const tmpZip = path.join(binDir, "tilth.zip");
-    const out = fs.createWriteStream(tmpZip);
-    res.pipe(out);
-    out.on("finish", () => {
-      out.close();
-      try {
-        execSync(`tar -xf "${tmpZip}" -C "${binDir}"`, { stdio: "ignore" });
-        fs.unlinkSync(tmpZip);
-      } catch {
-        console.error("tilth: failed to extract.");
-        process.exit(1);
-      }
-    });
+    fs.writeFileSync(tmpZip, buf);
+    try {
+      execSync(
+        `powershell -NoProfile -NonInteractive -Command "Expand-Archive -LiteralPath '${tmpZip}' -DestinationPath '${binDir}' -Force"`,
+        { stdio: "inherit" },
+      );
+      fs.unlinkSync(tmpZip);
+    } catch (err) {
+      console.error(`tilth: failed to extract: ${err.message}`);
+      process.exit(1);
+    }
   } else {
     const tar = require("child_process").spawn("tar", ["xz", "-C", binDir], {
       stdio: ["pipe", "inherit", "inherit"],
     });
-    res.pipe(tar.stdin);
+    tar.stdin.end(buf);
     tar.on("close", (code) => {
       if (code !== 0) {
         console.error("tilth: failed to extract.");
@@ -100,4 +152,26 @@ follow(url, 0, (res) => {
       console.log("tilth: installed successfully");
     });
   }
-});
+}
+
+const sidecarUrl = `${url}.sha256`;
+
+follow(sidecarUrl, 0, (sidecarRes) => {
+  buffer(sidecarRes, (sidecarBuf) => {
+    const expected = parseChecksum(sidecarBuf.toString("utf8"), sidecarUrl);
+
+    follow(url, 0, (archiveRes) => {
+      buffer(archiveRes, (archiveBuf) => {
+        const actual = crypto.createHash("sha256").update(archiveBuf).digest("hex");
+        if (actual !== expected) {
+          console.error("tilth: checksum mismatch — refusing to install");
+          console.error(`Expected: ${expected}`);
+          console.error(`Actual:   ${actual}`);
+          console.error("Install manually: cargo install --git https://github.com/paulnsorensen/tilth");
+          process.exit(1);
+        }
+        extract(archiveBuf);
+      });
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paulnsorensen/tilth-nightly",
-  "version": "0.0.0-experimental.0",
+  "version": "0.0.0-experimental.100.1",
   "description": "EXPERIMENTAL rolling build of paulnsorensen/tilth off main — unofficial fork, NOT the official `tilth` package",
   "bin": {
     "tilth": "run.js"

package/run.js

@@ -2,20 +2,37 @@
 
 "use strict";
 
-const { execFileSync } = require("child_process");
+const { spawn } = require("child_process");
 const path = require("path");
 
 const isWindows = process.platform === "win32";
 const binName = isWindows ? "tilth.exe" : "tilth";
 const bin = path.join(__dirname, "bin", binName);
 
-try {
-  execFileSync(bin, process.argv.slice(2), { stdio: "inherit" });
-} catch (err) {
-  if (err.status != null) {
-    process.exit(err.status);
-  }
+const child = spawn(bin, process.argv.slice(2), { stdio: "inherit" });
+
+const SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
+const forwarders = {};
+for (const sig of SIGNALS) {
+  forwarders[sig] = () => {
+    if (!child.killed) child.kill(sig);
+  };
+  process.on(sig, forwarders[sig]);
+}
+
+child.on("error", (err) => {
   console.error(`tilth: failed to run binary at ${bin}`);
   console.error(err.message);
   process.exit(1);
-}
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    // Remove only our own forwarders before re-raising, so the signal takes the
+    // default terminate action instead of being swallowed by a live handler.
+    for (const sig of SIGNALS) process.removeListener(sig, forwarders[sig]);
+    process.kill(process.pid, signal);
+  } else {
+    process.exit(code ?? 0);
+  }
+});