dprint 0.53.2 → 0.55.0

package/hashes.json

@@ -0,0 +1,17 @@
+{
+  "win32-x64": "31f22db986f62258be1f42a9f3c3e334d9277f938e8948af1055f0308d7d6f41",
+  "win32-arm64": "f2ca5597b61fd91fccc0807014dbdbbb4913298d390c85746e4086b9e6573b20",
+  "darwin-x64": "f95a06d61508250fd1de20638143b3de13fadc313d45a2ce716925b1d1f96ed2",
+  "darwin-arm64": "67442fee500dbfc53d4e019ab18de929868e796ffe9c24df9c905001efe1d822",
+  "linux-x64-glibc": "8155ae8516e6dba1cb528efb9e636ab666b1dec7f67ba3548bed77634eeedbbc",
+  "linux-x64-musl": "eac4737c1a7b2cab9e600ff66b80aa657a8185a3dc5b6bc7b11d82c4268932a0",
+  "linux-arm64-glibc": "8f8edab6a515a05af423b324c4dd2b862ad81146f4e9c932190a6c07245d16ca",
+  "linux-arm64-musl": "655e4d16a6bdfb19249c1ae2442b1ff7f654c6711280220b0ec2b98e351e15e0",
+  "linux-riscv64-glibc": "45fcb3902b3cb0b49a64130f478c67d613350edaba17cd6afa47e51b6fa86ef4",
+  "linux-loong64-glibc": "84b7a8e0a666a8dc429a57a3716c50648c8c807495dec129619e959a91c9e10e",
+  "linux-loong64-musl": "12f2b2c44787174fee2c23a9f92970a40217e4d11f275349b67ad00814425c3f",
+  "linux-ppc64-glibc": "b56ad03b133c2a8859116fcaeba60363403d31bc3017dc2ec0b829a162f8a65b",
+  "linux-ppc64-musl": "f114533153aa3d4ff4c731d13cddd19f0ef5384305f17c0b560ff895206500b0",
+  "android-arm64": "6b43057475766b02af46c94a5a3279175a4f2927ace088dfdccc7d148073ccb5",
+  "android-x64": "7829ce89f50afb15e720e939aed58d3c8f2a0dbdb3c6e84054afda1bf0127280"
+}

package/install_api.cjs

@@ -4,7 +4,7 @@
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
-/** @type {string | undefined} */
+/** @type {boolean | undefined} */
 let cachedIsMusl = undefined;
 
 module.exports = {
@@ -21,11 +21,18 @@ module.exports = {
     }
 
     const target = getTarget();
-    const sourcePackagePath = path.dirname(require.resolve("@dprint/" + target + "/package.json"));
-    const sourceExecutablePath = path.join(sourcePackagePath, dprintFileName);
+    const sourceExecutablePath = resolveSourceExecutablePath(target, dprintFileName);
 
-    if (!fs.existsSync(sourceExecutablePath)) {
-      throw new Error("Could not find executable for @dprint/" + target + " at " + sourceExecutablePath);
+    if (sourceExecutablePath == null) {
+      // the @dprint/<target> optional dependency isn't installed (for example
+      // the user ran `npm install --omit=optional`), so download the binary
+      // directly from the registry like esbuild does
+      downloadExecutable(target, dprintFileName, targetExecutablePath);
+      if (os.platform() !== "win32") {
+        // chmod +x
+        chmodX(targetExecutablePath);
+      }
+      return targetExecutablePath;
     }
 
     try {
@@ -59,6 +66,200 @@ module.exports = {
   },
 };
 
+/**
+ * Resolves the path to the executable provided by the @dprint/<target>
+ * optional dependency, or undefined when that package isn't installed.
+ * @param target {string}
+ * @param dprintFileName {string}
+ * @returns {string | undefined}
+ */
+function resolveSourceExecutablePath(target, dprintFileName) {
+  let sourcePackagePath;
+  try {
+    sourcePackagePath = path.dirname(require.resolve("@dprint/" + target + "/package.json"));
+  } catch {
+    // the optional dependency wasn't installed
+    return undefined;
+  }
+  const sourceExecutablePath = path.join(sourcePackagePath, dprintFileName);
+  return fs.existsSync(sourceExecutablePath) ? sourceExecutablePath : undefined;
+}
+
+/**
+ * Downloads the binary tarball for the target from the registry and extracts
+ * the executable to the destination path.
+ * @param target {string}
+ * @param dprintFileName {string}
+ * @param destinationPath {string}
+ */
+function downloadExecutable(target, dprintFileName, destinationPath) {
+  const version = require("./package.json").version;
+  const registry = (process.env.npm_config_registry || "https://registry.npmjs.org")
+    .replace(/\/+$/, "");
+  // npm tarball urls drop the scope from the file name (e.g.
+  // https://registry.npmjs.org/@dprint/win32-x64/-/win32-x64-1.0.0.tgz)
+  const tarballUrl = registry + "/@dprint/" + target + "/-/" + target + "-" + version + ".tgz";
+  console.error("[dprint] Optional dependency @dprint/" + target + " was not installed. Downloading from " + tarballUrl);
+  const tarballBuffer = downloadBufferSync(tarballUrl);
+  // files inside an npm tarball live under the "package/" directory
+  const executableBuffer = extractFileFromTarGzip(tarballBuffer, "package/" + dprintFileName);
+  verifyExecutableHash(target, executableBuffer);
+  atomicWriteFile(destinationPath, executableBuffer);
+}
+
+/**
+ * Verifies the downloaded executable against the hash recorded at build time
+ * so that we only ever run the exact binary that was published.
+ * @param target {string}
+ * @param buffer {Buffer}
+ */
+function verifyExecutableHash(target, buffer) {
+  let hashes;
+  try {
+    hashes = require("./hashes.json");
+  } catch (err) {
+    throw new Error("Could not load hashes.json to verify the downloaded binary: " + (err && err.message || err));
+  }
+  const expected = hashes[target];
+  if (typeof expected !== "string") {
+    throw new Error("No known hash for @dprint/" + target + " to verify the download against.");
+  }
+  const actual = require("crypto").createHash("sha256").update(buffer).digest("hex");
+  if (actual !== expected) {
+    throw new Error(
+      "Integrity check failed for the downloaded @dprint/" + target + " binary.\n"
+        + "  Expected sha256: " + expected + "\n"
+        + "  Actual sha256:   " + actual,
+    );
+  }
+}
+
+/**
+ * Downloads a url to a buffer synchronously. Prefer curl since it transparently
+ * supports proxies (http_proxy/https_proxy/no_proxy and npm's proxy config),
+ * redirects and TLS, then fall back to node for environments without curl.
+ * @param url {string}
+ * @returns {Buffer}
+ */
+function downloadBufferSync(url) {
+  const fromCurl = downloadBufferWithCurl(url);
+  return fromCurl != null ? fromCurl : downloadBufferWithNode(url);
+}
+
+/**
+ * @param url {string}
+ * @returns {Buffer | undefined} undefined when curl isn't available
+ */
+function downloadBufferWithCurl(url) {
+  // -f: fail on http errors, -s: silent, -S: still show errors, -L: follow redirects
+  const args = ["-fsSL"];
+  const proxy = process.env.npm_config_https_proxy
+    || process.env.npm_config_proxy
+    || process.env.HTTPS_PROXY
+    || process.env.https_proxy;
+  if (proxy) {
+    args.push("--proxy", proxy);
+  }
+  const noProxy = process.env.npm_config_noproxy || process.env.NO_PROXY || process.env.no_proxy;
+  if (noProxy) {
+    args.push("--noproxy", noProxy);
+  }
+  args.push("-o", "-", url);
+  try {
+    return require("child_process").execFileSync("curl", args, { maxBuffer: 512 * 1024 * 1024 });
+  } catch (err) {
+    if (err && err.code === "ENOENT") {
+      // curl isn't installed, fall back to node
+      return undefined;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Node has no synchronous https client, so spawn a child node process that
+ * streams the response to stdout. Does not support proxies.
+ * @param url {string}
+ * @returns {Buffer}
+ */
+function downloadBufferWithNode(url) {
+  const script = "const https=require('https');"
+    + "function f(u){https.get(u,r=>{"
+    + "const s=r.statusCode;"
+    + "if((s===301||s===302||s===303||s===307||s===308)&&r.headers.location){f(new URL(r.headers.location,u).toString());return;}"
+    + "if(s!==200){console.error('[dprint] Unexpected status code '+s+' downloading '+u);process.exit(1);}"
+    + "r.pipe(process.stdout);"
+    + "}).on('error',e=>{console.error(String(e&&e.message||e));process.exit(1);});}"
+    + "f(process.argv[1]);";
+  return require("child_process").execFileSync(
+    process.execPath,
+    ["-e", script, url],
+    { maxBuffer: 512 * 1024 * 1024 },
+  );
+}
+
+/**
+ * Extracts a single file from a gzipped tarball buffer.
+ * @param buffer {Buffer}
+ * @param subpath {string}
+ * @returns {Buffer}
+ */
+function extractFileFromTarGzip(buffer, subpath) {
+  const zlib = require("zlib");
+  let tar;
+  try {
+    tar = zlib.gunzipSync(buffer);
+  } catch (err) {
+    throw new Error("Invalid gzip data in downloaded tarball: " + (err && err.message || err));
+  }
+  let offset = 0;
+  while (offset < tar.length) {
+    const name = readTarString(tar, offset, 100);
+    const size = parseInt(readTarString(tar, offset + 124, 12).trim(), 8);
+    offset += 512;
+    if (!isNaN(size)) {
+      if (name === subpath) {
+        return tar.subarray(offset, offset + size);
+      }
+      // entries are padded to 512 byte boundaries
+      offset += (size + 511) & ~511;
+    }
+  }
+  throw new Error("Could not find " + JSON.stringify(subpath) + " in downloaded tarball");
+}
+
+/**
+ * @param buffer {Buffer}
+ * @param offset {number}
+ * @param length {number}
+ */
+function readTarString(buffer, offset, length) {
+  return buffer.toString("utf8", offset, offset + length).replace(/\0.*$/, "");
+}
+
+/**
+ * @param destinationPath {string}
+ * @param buffer {Buffer}
+ */
+function atomicWriteFile(destinationPath, buffer) {
+  const crypto = require("crypto");
+  const rand = crypto.randomBytes(4).toString("hex");
+  const tempFilePath = destinationPath + "." + rand;
+  fs.writeFileSync(tempFilePath, buffer);
+  try {
+    fs.renameSync(tempFilePath, destinationPath);
+  } catch (err) {
+    // will maybe throw when another process had already done this
+    // so just ignore and delete the created temporary file
+    try {
+      fs.unlinkSync(tempFilePath);
+    } catch (_err2) {
+      // ignore
+    }
+    throw err;
+  }
+}
+
 /** @filePath {string} */
 function chmodX(filePath) {
   const fd = fs.openSync(filePath, "r");
@@ -81,8 +282,8 @@ function getTarget() {
 
 function getArch() {
   const arch = os.arch();
-  if (arch !== "arm64" && arch !== "x64" && arch !== "riscv64" && arch !== "loong64") {
-    throw new Error("Unsupported architecture " + os.arch() + ". Only x64, aarch64, riscv64 and loong64 binaries are available.");
+  if (arch !== "arm64" && arch !== "x64" && arch !== "riscv64" && arch !== "loong64" && arch !== "ppc64") {
+    throw new Error("Unsupported architecture " + os.arch() + ". Only x64, arm64, riscv64, loong64 and ppc64 binaries are available.");
   }
   return arch;
 }
@@ -91,8 +292,8 @@ function getLinuxFamily() {
   return getIsMusl() ? "musl" : "glibc";
 
   function getIsMusl() {
-    // code adapted from https://github.com/lovell/detect-libc
-    // Copyright Apache 2.0 license, the detect-libc maintainers
+    // code adapted from https://github.com/napi-rs/package-template/blob/main/index.js
+    // which is in turn based on https://github.com/lovell/detect-libc (Apache 2.0 license)
     if (cachedIsMusl == null) {
       cachedIsMusl = innerGet();
     }
@@ -103,7 +304,14 @@ function getLinuxFamily() {
         if (os.platform() !== "linux") {
           return false;
         }
-        return isProcessReportMusl() || isConfMusl();
+        let musl = isMuslFromFilesystem();
+        if (musl == null) {
+          musl = isMuslFromReport();
+        }
+        if (musl == null) {
+          musl = isMuslFromChildProcess();
+        }
+        return musl;
       } catch (err) {
         // just in case
         console.warn("Error checking if musl.", err);
@@ -111,32 +319,52 @@ function getLinuxFamily() {
       }
     }
 
-    function isProcessReportMusl() {
-      if (!process.report) {
-        return false;
+    function isMuslFromFilesystem() {
+      try {
+        return fs.readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+      } catch {
+        return null;
+      }
+    }
+
+    function isMuslFromReport() {
+      if (typeof process.report?.getReport !== "function") {
+        return null;
+      }
+      // excludeNetwork avoids a slow reverse DNS lookup while generating the
+      // report, but it's a global flag so restore it once we're done
+      const originalExcludeNetwork = process.report.excludeNetwork;
+      let rawReport;
+      try {
+        process.report.excludeNetwork = true;
+        rawReport = process.report.getReport();
+      } finally {
+        process.report.excludeNetwork = originalExcludeNetwork;
       }
-      const rawReport = process.report.getReport();
       const report = typeof rawReport === "string" ? JSON.parse(rawReport) : rawReport;
-      if (!report || !(report.sharedObjects instanceof Array)) {
+      if (!report) {
+        return null;
+      }
+      if (report.header && report.header.glibcVersionRuntime) {
         return false;
       }
-      return report.sharedObjects.some(o => o.includes("libc.musl-") || o.includes("ld-musl-"));
-    }
-
-    function isConfMusl() {
-      const output = getCommandOutput();
-      const [_, ldd1] = output.split(/[\r\n]+/);
-      return ldd1 && ldd1.includes("musl");
+      if (Array.isArray(report.sharedObjects)) {
+        return report.sharedObjects.some(isFileMusl);
+      }
+      return false;
     }
 
-    function getCommandOutput() {
+    function isMuslFromChildProcess() {
       try {
-        const command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
-        return require("child_process").execSync(command, { encoding: "utf8" });
-      } catch (_err) {
-        return "";
+        return require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+      } catch {
+        return false;
       }
     }
+
+    function isFileMusl(f) {
+      return f.includes("libc.musl-") || f.includes("ld-musl-");
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dprint",
-  "version": "0.53.2",
+  "version": "0.55.0",
   "description": "Pluggable and configurable code formatting platform written in Rust.",
   "bin": "bin.cjs",
   "repository": {
@@ -22,16 +22,20 @@
     "postinstall": "node ./install.cjs"
   },
   "optionalDependencies": {
-    "@dprint/win32-x64": "0.53.2",
-    "@dprint/win32-arm64": "0.53.2",
-    "@dprint/darwin-x64": "0.53.2",
-    "@dprint/darwin-arm64": "0.53.2",
-    "@dprint/linux-x64-glibc": "0.53.2",
-    "@dprint/linux-x64-musl": "0.53.2",
-    "@dprint/linux-arm64-glibc": "0.53.2",
-    "@dprint/linux-arm64-musl": "0.53.2",
-    "@dprint/linux-riscv64-glibc": "0.53.2",
-    "@dprint/linux-loong64-glibc": "0.53.2",
-    "@dprint/linux-loong64-musl": "0.53.2"
+    "@dprint/win32-x64": "0.55.0",
+    "@dprint/win32-arm64": "0.55.0",
+    "@dprint/darwin-x64": "0.55.0",
+    "@dprint/darwin-arm64": "0.55.0",
+    "@dprint/linux-x64-glibc": "0.55.0",
+    "@dprint/linux-x64-musl": "0.55.0",
+    "@dprint/linux-arm64-glibc": "0.55.0",
+    "@dprint/linux-arm64-musl": "0.55.0",
+    "@dprint/linux-riscv64-glibc": "0.55.0",
+    "@dprint/linux-loong64-glibc": "0.55.0",
+    "@dprint/linux-loong64-musl": "0.55.0",
+    "@dprint/linux-ppc64-glibc": "0.55.0",
+    "@dprint/linux-ppc64-musl": "0.55.0",
+    "@dprint/android-arm64": "0.55.0",
+    "@dprint/android-x64": "0.55.0"
   }
 }