hugo-extended 0.154.2 → 0.154.3-sudoless.1

package/dist/lib/utils.mjs

@@ -0,0 +1,191 @@
+import { getEnvConfig } from "./env.mjs";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/lib/utils.ts
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+* The first Hugo version that uses .pkg installers for macOS.
+* Versions before this use .tar.gz archives.
+*
+* @see https://github.com/gohugoio/hugo/issues/14135
+*/
+const MACOS_PKG_MIN_VERSION = "0.153.0";
+/**
+* Compares two semver version strings.
+*
+* @param a - First version string (e.g., "0.153.0")
+* @param b - Second version string (e.g., "0.152.1")
+* @returns -1 if a < b, 0 if a === b, 1 if a > b
+*/
+function compareVersions(a, b) {
+	const partsA = a.split(".").map((n) => Number.parseInt(n, 10));
+	const partsB = b.split(".").map((n) => Number.parseInt(n, 10));
+	const maxLen = Math.max(partsA.length, partsB.length);
+	for (let i = 0; i < maxLen; i++) {
+		const numA = partsA[i] ?? 0;
+		const numB = partsB[i] ?? 0;
+		if (numA < numB) return -1;
+		if (numA > numB) return 1;
+	}
+	return 0;
+}
+/**
+* Checks if a version uses .pkg installers for macOS.
+* Hugo v0.153.0+ uses .pkg, earlier versions use .tar.gz.
+*
+* @param version - The Hugo version to check
+* @returns true if the version uses .pkg installers on macOS
+*/
+function usesMacOSPkg(version) {
+	return compareVersions(version, MACOS_PKG_MIN_VERSION) >= 0;
+}
+/**
+* Gets the Hugo version to install.
+*
+* Resolution order:
+* 1. HUGO_OVERRIDE_VERSION environment variable (if set)
+* 2. `hugoVersion` field in package.json (for emergency overrides)
+* 3. `version` field in package.json (should match Hugo release)
+*
+* @throws {Error} If package.json cannot be found and no override is set
+* @returns The version string (e.g., "0.88.1")
+*/
+function getPkgVersion() {
+	const envConfig = getEnvConfig();
+	if (envConfig.overrideVersion) return envConfig.overrideVersion;
+	const packageJsonPath = path.join(__dirname, "..", "..", "package.json");
+	try {
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+		return packageJson.hugoVersion || packageJson.version;
+	} catch {
+		throw new Error(`Could not find or read package.json at ${packageJsonPath}`);
+	}
+}
+/**
+* Generates the full URL to a Hugo release file.
+*
+* By default, downloads from GitHub releases. Can be overridden with
+* HUGO_MIRROR_BASE_URL for mirrors or air-gapped environments.
+*
+* @param version - The Hugo version number (e.g., "0.88.1")
+* @param filename - The release filename (e.g., "hugo_extended_0.88.1_darwin-universal.pkg")
+* @returns The complete download URL for the release file
+*/
+function getReleaseUrl(version, filename) {
+	const envConfig = getEnvConfig();
+	if (envConfig.downloadBaseUrl) return `${envConfig.downloadBaseUrl.replace(/\/$/, "")}/${filename}`;
+	return `https://github.com/gohugoio/hugo/releases/download/v${version}/${filename}`;
+}
+/**
+* Gets the Hugo binary filename for the current platform.
+*
+* @returns "hugo.exe" on Windows, "hugo" on all other platforms
+*/
+function getBinFilename() {
+	return process.platform === "win32" ? "hugo.exe" : "hugo";
+}
+/**
+* Gets the absolute path to the Hugo binary.
+*
+* Resolution order:
+* 1. HUGO_BIN_PATH environment variable (if set)
+* 2. Local bin directory (./bin/hugo or ./bin/hugo.exe)
+*
+* @returns The absolute path to hugo binary
+*/
+function getBinPath() {
+	const envConfig = getEnvConfig();
+	if (envConfig.binPath) return envConfig.binPath;
+	return path.join(__dirname, "..", "..", "bin", getBinFilename());
+}
+/**
+* Executes the Hugo binary and returns its version string.
+*
+* @param bin - The absolute path to the Hugo binary
+* @returns The version output string (e.g., "hugo v0.88.1-5BC54738+extended darwin/arm64 BuildDate=...")
+* @throws {Error} If the binary cannot be executed
+*/
+function getBinVersion(bin) {
+	return execFileSync(bin, ["version"]).toString().trim();
+}
+/**
+* Checks if the Hugo binary exists at the specified path.
+*
+* @param bin - The absolute path to check for the Hugo binary
+* @returns `true` if the file exists, `false` if it doesn't
+* @throws {Error} If an unexpected error occurs (other than ENOENT)
+*/
+function doesBinExist(bin) {
+	try {
+		if (fs.existsSync(bin)) return true;
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code !== "ENOENT") throw error;
+		return false;
+	}
+	return false;
+}
+/**
+* Determines the correct Hugo release filename for the current platform and architecture.
+*
+* Hugo Extended is available for:
+* - macOS: x64 and ARM64 (universal binaries as of v0.102.0)
+* - Linux: x64 and ARM64
+* - Windows: x64 only
+*
+* Other platform/architecture combinations fall back to vanilla Hugo where available.
+* Set HUGO_NO_EXTENDED=1 to force vanilla Hugo even on platforms that support Extended.
+*
+* Note: macOS uses .pkg installers starting from v0.153.0. Earlier versions use .tar.gz.
+*
+* @param version - The Hugo version number (e.g., "0.88.1")
+* @returns The release filename if supported (e.g., "hugo_extended_0.88.1_darwin-universal.pkg"),
+*          or `null` if the platform/architecture combination is not supported
+*/
+function getReleaseFilename(version) {
+	const { platform, arch } = process;
+	const forceStandard = getEnvConfig().forceStandard;
+	const edition = (extended, standard) => forceStandard ? standard : extended;
+	if (platform === "darwin" && (arch === "x64" || arch === "arm64")) {
+		if (usesMacOSPkg(version)) return edition(`hugo_extended_${version}_darwin-universal.pkg`, `hugo_${version}_darwin-universal.pkg`);
+		return edition(`hugo_extended_${version}_darwin-universal.tar.gz`, `hugo_${version}_darwin-universal.tar.gz`);
+	}
+	return platform === "win32" && arch === "x64" ? edition(`hugo_extended_${version}_windows-amd64.zip`, `hugo_${version}_windows-amd64.zip`) : platform === "win32" && arch === "arm64" ? `hugo_${version}_windows-arm64.zip` : platform === "linux" && arch === "x64" ? edition(`hugo_extended_${version}_linux-amd64.tar.gz`, `hugo_${version}_linux-amd64.tar.gz`) : platform === "linux" && arch === "arm64" ? edition(`hugo_extended_${version}_linux-arm64.tar.gz`, `hugo_${version}_linux-arm64.tar.gz`) : platform === "freebsd" && arch === "x64" ? `hugo_${version}_freebsd-amd64.tar.gz` : platform === "openbsd" && arch === "x64" ? `hugo_${version}_openbsd-amd64.tar.gz` : null;
+}
+/**
+* Generates the checksums filename for a given Hugo version.
+*
+* @param version - The Hugo version number (e.g., "0.88.1")
+* @returns The checksums filename (e.g., "hugo_0.88.1_checksums.txt")
+*/
+function getChecksumFilename(version) {
+	return `hugo_${version}_checksums.txt`;
+}
+/**
+* Determines if a release filename corresponds to Hugo Extended or vanilla Hugo.
+*
+* @param releaseFile - The release filename to check (e.g., "hugo_extended_0.88.1_darwin-universal.pkg")
+* @returns `true` if the release is Hugo Extended, `false` if it's vanilla Hugo
+*/
+function isExtended(releaseFile) {
+	return releaseFile.startsWith("hugo_extended_");
+}
+/**
+* Logger utility that respects the HUGO_QUIET setting.
+*/
+const logger = {
+	info: (message) => {
+		if (!getEnvConfig().quiet) console.info(message);
+	},
+	warn: (message) => {
+		if (!getEnvConfig().quiet) console.warn(`⚠ ${message}`);
+	},
+	error: (message) => {
+		console.error(`✖ ${message}`);
+	}
+};
+
+//#endregion
+export { compareVersions, doesBinExist, getBinFilename, getBinPath, getBinVersion, getChecksumFilename, getPkgVersion, getReleaseFilename, getReleaseUrl, isExtended, logger, usesMacOSPkg };

package/package.json

@@ -1,50 +1,77 @@
 {
   "name": "hugo-extended",
-  "version": "0.154.2",
+  "version": "0.154.3-sudoless.1",
+  "hugoVersion": "0.154.3",
   "description": "✏️ Plug-and-play binary wrapper for Hugo Extended, the awesomest static-site generator.",
   "license": "MIT",
-  "homepage": "https://github.com/jakejarvis/hugo-extended",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jakejarvis/hugo-extended.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jakejarvis/hugo-extended/issues"
+  },
   "author": {
     "name": "Jake Jarvis",
     "email": "jake@jarv.is",
     "url": "https://github.com/jakejarvis"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jakejarvis/hugo-extended.git"
-  },
   "publishConfig": {
     "access": "public"
   },
+  "type": "module",
+  "main": "./dist/hugo.mjs",
+  "module": "./dist/hugo.mjs",
+  "types": "./dist/hugo.d.mts",
+  "bin": {
+    "hugo": "dist/cli.mjs",
+    "hugo-extended": "dist/cli.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/hugo.d.mts",
+      "import": "./dist/hugo.mjs",
+      "default": "./dist/hugo.mjs"
+    },
+    "./types": {
+      "types": "./dist/generated/types.d.mts",
+      "default": "./dist/generated/types.mjs"
+    }
+  },
   "files": [
-    "index.js",
-    "index.d.ts",
-    "postinstall.js",
-    "lib"
+    "dist",
+    "postinstall.js"
   ],
-  "bin": {
-    "hugo": "lib/cli.js",
-    "hugo-extended": "lib/cli.js"
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "generate-types": "bun scripts/generate-types.ts",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration",
+    "test:e2e": "vitest run tests/e2e",
+    "test:coverage": "vitest run --coverage",
+    "postinstall": "node postinstall.js",
+    "prepublishOnly": "npm run generate-types && npm run build"
   },
-  "type": "module",
-  "exports": "./index.js",
-  "types": "./index.d.ts",
   "dependencies": {
     "adm-zip": "^0.5.16",
-    "log-symbols": "^7.0.1",
-    "read-package-up": "^12.0.0",
     "tar": "^7.5.2"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.3.11",
     "@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"
+    "@types/node": "^25.0.3",
+    "@types/tar": "^6.1.13",
+    "@vitest/coverage-v8": "^4.0.16",
+    "tinyexec": "^1.0.2",
+    "tsdown": "^0.19.0-beta.5",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
   },
   "engines": {
     "node": ">=18.17"

package/postinstall.js

@@ -1,4 +1,58 @@
-import install from "./lib/install.js";
+#!/usr/bin/env node
 
-// Install Hugo right off the bat.
-(async () => await install())();
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Postinstall wrapper script that properly handles errors during Hugo binary installation.
+ * This script imports and executes the install function, logging any errors with full stack traces
+ * and exiting with a non-zero code on failure.
+ *
+ * During development/CI (before build), the dist folder won't exist and this script will exit gracefully.
+ * For published packages, the dist folder is included and installation will proceed.
+ *
+ * Environment variables:
+ * - HUGO_SKIP_DOWNLOAD: Skip installation entirely (useful for CI caching, Docker layers)
+ */
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const installPath = join(__dirname, "dist", "lib", "install.mjs");
+
+/**
+ * Check if an environment variable is set to a truthy value.
+ * @param {string} name - Environment variable name
+ * @returns {boolean}
+ */
+function isEnvTruthy(name) {
+  const value = process.env[name];
+  if (!value) return false;
+  return ["1", "true", "yes", "on"].includes(value.toLowerCase().trim());
+}
+
+async function run() {
+  // Skip installation if HUGO_SKIP_DOWNLOAD is set
+  if (isEnvTruthy("HUGO_SKIP_DOWNLOAD")) {
+    console.log("Skipping Hugo installation (HUGO_SKIP_DOWNLOAD is set)");
+    process.exit(0);
+  }
+
+  // Skip installation if dist folder doesn't exist (development/CI environment)
+  if (!existsSync(installPath)) {
+    console.log(
+      "Skipping Hugo installation (dist not found - likely in CI or development environment)",
+    );
+    process.exit(0);
+  }
+
+  try {
+    const m = await import("./dist/lib/install.mjs");
+    await m.default();
+  } catch (error) {
+    console.error("Hugo installation failed:");
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+run();

package/index.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="node" />
-
-/**
- * @returns A promise of the absolute path to the Hugo executable (`hugo.exe` on
- * Windows, simply `hugo` otherwise) once it's installed.
- */
-export default function hugo(): Promise<string>;

package/index.js

@@ -1,22 +0,0 @@
-import logSymbols from "log-symbols";
-import install from "./lib/install.js";
-import { getBinPath, doesBinExist } from "./lib/utils.js";
-
-const hugo = async () => {
-  const bin = getBinPath();
-
-  // A fix for fleeting ENOENT errors, where Hugo seems to disappear. For now,
-  // just reinstall Hugo when it's missing and then continue normally like
-  // nothing happened.
-  // See: https://github.com/jakejarvis/hugo-extended/issues/81
-  if (!doesBinExist(bin)) {
-    // Hugo isn't there for some reason. Try re-installing.
-    console.info(`${logSymbols.info} Hugo is missing, reinstalling now...`);
-    await install();
-  }
-
-  return bin;
-};
-
-// The only thing this module really exports is the absolute path to Hugo:
-export default hugo;

package/lib/cli.js

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from "child_process";
-import hugo from "../index.js";
-
-(async () => {
-  const args = process.argv.slice(2);
-  const bin = await hugo();
-
-  spawn(bin, args, { stdio: "inherit" })
-    .on("exit", (code) => {
-      // forward Hugo's exit code so this module itself reports success/failure
-      process.exitCode = code;
-    });
-})();

package/lib/install.js

@@ -1,144 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { fileURLToPath } from "url";
-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,
-  getReleaseUrl,
-  getReleaseFilename,
-  getBinFilename,
-  getBinVersion,
-  getChecksumFilename,
-  isExtended,
-} from "./utils.js";
-
-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();
-    const releaseFile = getReleaseFilename(version);
-    const checksumFile = getChecksumFilename(version);
-    const binFile = getBinFilename();
-
-    if (!releaseFile) {
-      throw new Error(`Are you sure this platform is supported? See: https://github.com/gohugoio/hugo/releases/tag/v${version}`);
-    }
-
-    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);
-
-        // Cleanup zip
-        fs.unlinkSync(downloadPath);
-      } else if (releaseFile.endsWith(".tar.gz")) {
-        await tar.x({
-          file: downloadPath,
-          cwd: vendorDir,
-        });
-
-        // Cleanup tar.gz
-        fs.unlinkSync(downloadPath);
-      }
-
-      const binPath = path.join(vendorDir, binFile);
-      if (fs.existsSync(binPath)) {
-        fs.chmodSync(binPath, 0o755);
-      }
-    }
-
-    console.info(`${logSymbols.success} Hugo installed successfully!`);
-
-    // 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) {
-    console.error(`${logSymbols.error} Hugo installation failed. :(`);
-    throw error;
-  }
-}
-
-export default install;

package/lib/utils.js

@@ -1,109 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { fileURLToPath } from "url";
-import { execFileSync } from "child_process";
-import { readPackageUpSync } from "read-package-up";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-// This package's version number (should) always match the Hugo release we want.
-// We check for a `hugoVersion` field in package.json just in case it doesn't
-// match in the future (from pushing an emergency package update, etc.).
-export function getPkgVersion() {
-  const { packageJson } = readPackageUpSync({ cwd: __dirname });
-  return packageJson.hugoVersion || packageJson.version;
-}
-
-// Generate the full GitHub URL to a given release file.
-export function getReleaseUrl(version, filename) {
-  return `https://github.com/gohugoio/hugo/releases/download/v${version}/${filename}`;
-}
-
-// Binary is named `hugo.exe` on Windows, and simply `hugo` otherwise.
-export function getBinFilename() {
-  return process.platform === "win32" ? "hugo.exe" : "hugo";
-}
-
-// 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()
-  );
-}
-
-// Returns the output of the `hugo version` command, i.e.:
-//   "hugo v0.88.1-5BC54738+extended darwin/arm64 BuildDate=..."
-export function getBinVersion(bin) {
-  const stdout = execFileSync(bin, ["version"]);
-  return stdout.toString().trim();
-}
-
-// Simply detect if the given file exists.
-export function doesBinExist(bin) {
-  try {
-    if (fs.existsSync(bin)) {
-      return true;
-    }
-  } catch (error) {
-    // something bad happened besides Hugo not existing
-    if (error.code !== "ENOENT") {
-      throw error;
-    }
-
-    return false;
-  }
-}
-
-// Hugo Extended supports: macOS x64 / ARM64, Linux x64 / ARM64, Windows x64.
-// All other combos fall back to vanilla Hugo. There are surely much better ways
-// to do this but this is easy to read/update. :)
-export function getReleaseFilename(version) {
-  const { platform, arch } = process;
-
-  const filename =
-    // macOS: as of 0.102.0, binaries are universal
-    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`
-
-    // Linux
-    : 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`
-
-    // OpenBSD
-    : platform === "openbsd" && arch === "x64"
-      ? `hugo_${version}_openbsd-amd64.tar.gz`
-
-    // not gonna work :(
-    : null;
-
-  return filename;
-}
-
-// Simple formula for the checksums.txt file.
-export function getChecksumFilename(version) {
-  return `hugo_${version}_checksums.txt`;
-}
-
-// Check if Hugo extended is being downloaded (as opposed to plain Hugo) based on the release filename.
-export function isExtended(releaseFile) {
-  return releaseFile.startsWith("hugo_extended_");
-}