hugo-extended 0.152.1 → 0.153.0

package/lib/install.js

@@ -1,7 +1,11 @@
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
-import downloader from "careful-downloader";
+import { spawnSync } from "child_process";
+import { pipeline } from "stream/promises";
+import crypto from "crypto";
+import * as tar from "tar";
+import AdmZip from "adm-zip";
 import logSymbols from "log-symbols";
 import {
   getPkgVersion,
@@ -15,6 +19,41 @@ import {
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+async function downloadFile(url, dest) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download ${url}: ${response.statusText}`);
+  }
+  await pipeline(response.body, fs.createWriteStream(dest));
+}
+
+async function verifyChecksum(filePath, checksumUrl, filename) {
+  const response = await fetch(checksumUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to download checksums: ${response.statusText}`);
+  }
+  const checksums = await response.text();
+
+  // checksums file format: "sha256  filename"
+  const expectedChecksum = checksums
+    .split("\n")
+    .find((line) => line.endsWith(filename))
+    ?.split(/\s+/)[0];
+
+  if (!expectedChecksum) {
+    throw new Error(`Checksum for ${filename} not found in checksums file.`);
+  }
+
+  const fileBuffer = fs.readFileSync(filePath);
+  const hash = crypto.createHash("sha256");
+  hash.update(fileBuffer);
+  const actualChecksum = hash.digest("hex");
+
+  if (actualChecksum !== expectedChecksum) {
+    throw new Error(`Checksum mismatch! Expected ${expectedChecksum}, got ${actualChecksum}`);
+  }
+}
+
 async function install() {
   try {
     const version = getPkgVersion();
@@ -22,36 +61,81 @@ async function install() {
     const checksumFile = getChecksumFilename(version);
     const binFile = getBinFilename();
 
-    // stop here if there's nothing we can download
-    if (!releaseFile)
+    if (!releaseFile) {
       throw new Error(`Are you sure this platform is supported? See: https://github.com/gohugoio/hugo/releases/tag/v${version}`);
+    }
 
-    // warn if platform doesn't support Hugo Extended, proceed with vanilla Hugo
-    if (!isExtended(releaseFile))
+    if (!isExtended(releaseFile)) {
       console.warn(`${logSymbols.info} Hugo Extended isn't supported on this platform, downloading vanilla Hugo instead.`);
+    }
+
+    // Prepare vendor directory
+    const vendorDir = path.join(__dirname, "..", "vendor");
+    if (!fs.existsSync(vendorDir)) {
+      fs.mkdirSync(vendorDir, { recursive: true });
+    }
+
+    const releaseUrl = getReleaseUrl(version, releaseFile);
+    const checksumUrl = getReleaseUrl(version, checksumFile);
+    const downloadPath = path.join(vendorDir, releaseFile);
+
+    console.info(`${logSymbols.info} Downloading ${releaseFile}...`);
+    await downloadFile(releaseUrl, downloadPath);
+
+    console.info(`${logSymbols.info} Verifying checksum...`);
+    await verifyChecksum(downloadPath, checksumUrl, releaseFile);
+
+    if (process.platform === "darwin") {
+      console.info(`${logSymbols.info} Installing ${releaseFile} (requires sudo)...`);
+      // Run MacOS installer
+      const result = spawnSync("sudo", ["installer", "-pkg", downloadPath, "-target", "/"], {
+        stdio: "inherit",
+      });
+
+      if (result.error) throw result.error;
+      if (result.status !== 0) {
+        throw new Error(`Installer failed with exit code ${result.status}`);
+      }
+
+      // Cleanup downloaded pkg
+      fs.unlinkSync(downloadPath);
+    } else {
+      console.info(`${logSymbols.info} Extracting...`);
+
+      if (releaseFile.endsWith(".zip")) {
+        const zip = new AdmZip(downloadPath);
+        zip.extractAllTo(vendorDir, true);
 
-    // download release from GitHub and verify its checksum
-    const download = await downloader(getReleaseUrl(version, releaseFile), {
-      checksumUrl: getReleaseUrl(version, checksumFile),
-      filename: releaseFile,
-      destDir: path.join(__dirname, "..", "vendor"),
-      algorithm: "sha256",
-      extract: true,
-    });
+        // Cleanup zip
+        fs.unlinkSync(downloadPath);
+      } else if (releaseFile.endsWith(".tar.gz")) {
+        await tar.x({
+          file: downloadPath,
+          cwd: vendorDir,
+        });
 
-    // full path to the binary
-    const installedToPath = path.join(download, binFile);
+        // Cleanup tar.gz
+        fs.unlinkSync(downloadPath);
+      }
 
-    // ensure hugo[.exe] is executable
-    fs.chmodSync(installedToPath, 0o755);
+      const binPath = path.join(vendorDir, binFile);
+      if (fs.existsSync(binPath)) {
+        fs.chmodSync(binPath, 0o755);
+      }
+    }
 
     console.info(`${logSymbols.success} Hugo installed successfully!`);
-    console.info(getBinVersion(installedToPath));
 
-    // return the full path to our Hugo binary
-    return installedToPath;
+    // Check version
+    if (process.platform === "darwin") {
+       console.info(getBinVersion("/usr/local/bin/hugo"));
+       return "/usr/local/bin/hugo";
+    } else {
+       const binPath = path.join(vendorDir, binFile);
+       console.info(getBinVersion(binPath));
+       return binPath;
+    }
   } catch (error) {
-    // pass whatever error occurred along the way to console
     console.error(`${logSymbols.error} Hugo installation failed. :(`);
     throw error;
   }

package/lib/utils.js

@@ -2,7 +2,7 @@ import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
 import { execFileSync } from "child_process";
-import { readPackageUpSync } from "read-pkg-up";
+import { readPackageUpSync } from "read-package-up";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -26,11 +26,13 @@ export function getBinFilename() {
 
 // Simple shortcut to ./vendor/hugo[.exe] from package root.
 export function getBinPath() {
+  if (process.platform === "darwin") return "/usr/local/bin/hugo";
+
   return path.join(
     __dirname,
     "..",
     "vendor",
-    getBinFilename(),
+    getBinFilename()
   );
 }
 
@@ -44,12 +46,14 @@ export function getBinVersion(bin) {
 // Simply detect if the given file exists.
 export function doesBinExist(bin) {
   try {
-    if (fs.existsSync(bin))
+    if (fs.existsSync(bin)) {
       return true;
+    }
   } catch (error) {
     // something bad happened besides Hugo not existing
-    if (error.code !== "ENOENT")
+    if (error.code !== "ENOENT") {
       throw error;
+    }
 
     return false;
   }
@@ -63,33 +67,33 @@ export function getReleaseFilename(version) {
 
   const filename =
     // macOS: as of 0.102.0, binaries are universal
-    platform === "darwin" && arch === "x64" ?
-      `hugo_extended_${version}_darwin-universal.tar.gz` :
-    platform === "darwin" && arch === "arm64" ?
-      `hugo_extended_${version}_darwin-universal.tar.gz` :
+    platform === "darwin" && arch === "x64"
+      ? `hugo_extended_${version}_darwin-universal.pkg`
+    : platform === "darwin" && arch === "arm64"
+      ? `hugo_extended_${version}_darwin-universal.pkg`
 
     // Windows
-    platform === "win32" && arch === "x64" ?
-      `hugo_extended_${version}_windows-amd64.zip` :
-    platform === "win32" && arch === "arm64" ?
-      `hugo_${version}_windows-arm64.zip` :
+    : platform === "win32" && arch === "x64"
+      ? `hugo_extended_${version}_windows-amd64.zip`
+    : platform === "win32" && arch === "arm64"
+      ? `hugo_${version}_windows-arm64.zip`
 
     // Linux
-    platform === "linux" && arch === "x64" ?
-      `hugo_extended_${version}_linux-amd64.tar.gz` :
-    platform === "linux" && arch === "arm64" ?
-      `hugo_extended_${version}_linux-arm64.tar.gz` :
+    : platform === "linux" && arch === "x64"
+      ? `hugo_extended_${version}_linux-amd64.tar.gz`
+    : platform === "linux" && arch === "arm64"
+      ? `hugo_extended_${version}_linux-arm64.tar.gz`
 
     // FreeBSD
-    platform === "freebsd" && arch === "x64" ?
-      `hugo_${version}_freebsd-amd64.tar.gz` :
+    : platform === "freebsd" && arch === "x64"
+      ? `hugo_${version}_freebsd-amd64.tar.gz`
 
     // OpenBSD
-    platform === "openbsd" && arch === "x64" ?
-      `hugo_${version}_openbsd-amd64.tar.gz` :
+    : platform === "openbsd" && arch === "x64"
+      ? `hugo_${version}_openbsd-amd64.tar.gz`
 
     // not gonna work :(
-    null;
+    : null;
 
   return filename;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hugo-extended",
-  "version": "0.152.1",
+  "version": "0.153.0",
   "description": "✏️ Plug-and-play binary wrapper for Hugo Extended, the awesomest static-site generator.",
   "license": "MIT",
   "homepage": "https://github.com/jakejarvis/hugo-extended",
@@ -13,6 +13,9 @@
     "type": "git",
     "url": "git+https://github.com/jakejarvis/hugo-extended.git"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "files": [
     "index.js",
     "index.d.ts",
@@ -27,18 +30,24 @@
   "exports": "./index.js",
   "types": "./index.d.ts",
   "dependencies": {
-    "careful-downloader": "^3.0.0",
-    "log-symbols": "^5.1.0",
-    "read-pkg-up": "^9.1.0"
+    "adm-zip": "^0.5.16",
+    "log-symbols": "^7.0.1",
+    "read-package-up": "^12.0.0",
+    "tar": "^7.5.2"
   },
   "devDependencies": {
-    "@jakejarvis/eslint-config": "*",
-    "del": "^7.1.0",
-    "eslint": "^8.56.0",
-    "mocha": "^10.3.0"
+    "@types/adm-zip": "^0.5.7",
+    "del": "^8.0.1",
+    "eslint": "^9.39.2",
+    "globals": "^16.5.0",
+    "mocha": "^11.7.5"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js",
+    "test": "eslint . && mocha"
   },
   "engines": {
-    "node": ">=18.12"
+    "node": ">=18.17"
   },
   "keywords": [
     "hugo",
@@ -58,24 +67,5 @@
     "frontmatter",
     "go",
     "golang"
-  ],
-  "eslintConfig": {
-    "extends": "@jakejarvis/eslint-config",
-    "parserOptions": {
-      "ecmaVersion": 2020,
-      "sourceType": "module"
-    },
-    "env": {
-      "node": true,
-      "es6": true
-    },
-    "ignorePatterns": [
-      "vendor/**",
-      "*.d.ts"
-    ]
-  },
-  "scripts": {
-    "postinstall": "node postinstall.js",
-    "test": "eslint . && mocha"
-  }
-}
+  ]
+}