hugo-extended/install.js

"use strict";

const fs = require("fs");
const stream = require("stream");
const { promisify } = require("util");
const path = require("path");
const execa = require("execa");
const chalk = require("chalk");
const got = require("got");
const decompress = require("decompress");
const sumchecker = require("sumchecker");

installHugo()
  .then((bin) => {
    // print output of `hugo version` to console
    const { stdout } = execa.sync(bin, ["version"]);
    return stdout;
  })
  .then((version) => {
    console.log(chalk.green("✔ Hugo installed successfully!"));
    console.log(version);
  })
  .catch((error) => {
    // pass whatever error occured along the way along to console
    console.error(chalk.red("✖ Hugo installation failed. :("));
    throw error;
  });

async function installHugo() {
  // this package's version number (should) always match the Hugo release we want
  const { version } = require("./package.json");
  const downloadBaseUrl = `https://github.com/gohugoio/hugo/releases/download/v${version}/`;
  const releaseFile = getArchiveFilename(version, process.platform, process.arch);
  const checksumFile = `hugo_${version}_checksums.txt`;

  // stop here if there's nothing we can download
  if (!releaseFile) {
    throw "Are you sure this platform is supported?";
  }

  const releaseUrl = downloadBaseUrl + releaseFile;
  const checksumUrl = downloadBaseUrl + checksumFile;
  const vendorDir = path.join(__dirname, "vendor");
  const archivePath = path.join(vendorDir, releaseFile);
  const checksumPath = path.join(vendorDir, checksumFile);
  const binName = process.platform === "win32" ? "hugo.exe" : "hugo";
  const binPath = path.join(vendorDir, binName);

  try {
    // ensure the target directory exists
    await fs.promises.mkdir(vendorDir, { recursive: true });

    await Promise.all([
      // fetch the archive file from GitHub
      downloadFile(releaseUrl, archivePath),
      // fetch the checksum file from GitHub
      downloadFile(checksumUrl, checksumPath),
    ]);

    // validate the checksum of the download
    await checkChecksum(vendorDir, checksumPath, releaseFile);

    // extract the downloaded file
    await decompress(archivePath, vendorDir);
  } finally {
    await Promise.all([
      // delete the downloaded archive when finished
      deleteFile(archivePath),
      // ...and the checksum file
      deleteFile(checksumPath),
    ]);
  }

  // return the full path to our Hugo binary
  return binPath;
}

async function downloadFile(url, dest) {
  const pipeline = promisify(stream.pipeline);
  return await pipeline(
    got.stream(url, { followRedirect: true }),  // GitHub releases redirect to unpredictable URLs
    fs.createWriteStream(dest),
  );
}

async function deleteFile(path) {
  if (fs.existsSync(path)) {
    return await fs.promises.unlink(path);
  } else {
    return;
  }
}

async function checkChecksum(baseDir, checksumFile, binFile) {
  const checker = new sumchecker.ChecksumValidator("sha256", checksumFile, {
    // returns a completely different hash without this for some reason
    defaultTextEncoding: "binary",
  });

  return await checker.validate(baseDir, binFile);
}

// Hugo Extended supports: macOS x64, macOS ARM64, Linux x64, 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. :)
function getArchiveFilename(version, os, arch) {
  const filename =
    // macOS
    os === "darwin" && arch === "x64" ?
      `hugo_extended_${version}_macOS-64bit.tar.gz` :
    os === "darwin" && arch === "arm64" ?
      `hugo_extended_${version}_macOS-ARM64.tar.gz` :

    // Windows
    os === "win32" && arch === "x64" ?
      `hugo_extended_${version}_Windows-64bit.zip` :
    os === "win32" && arch.endsWith("32") ?
      `hugo_${version}_Windows-32bit.zip` :

    // Linux
    os === "linux" && arch === "x64" ?
      `hugo_extended_${version}_Linux-64bit.tar.gz` :
    os === "linux" && arch.endsWith("32") ?
      `hugo_${version}_Linux-32bit.tar.gz` :
    os === "linux" && arch === "arm" ?
      `hugo_${version}_Linux-ARM.tar.gz` :
    os === "linux" && arch === "arm64" ?
      `hugo_${version}_Linux-ARM64.tar.gz` :

    // FreeBSD
    os === "freebsd" && arch === "x64" ?
      `hugo_${version}_FreeBSD-64bit.tar.gz` :
    os === "freebsd" && arch.endsWith("32") ?
      `hugo_${version}_FreeBSD-32bit.tar.gz` :
    os === "freebsd" && arch === "arm" ?
      `hugo_${version}_FreeBSD-ARM.tar.gz` :
    os === "freebsd" && arch === "arm64" ?
      `hugo_${version}_FreeBSD-ARM64.tar.gz` :

    // OpenBSD
    os === "openbsd" && arch === "x64" ?
      `hugo_${version}_OpenBSD-64bit.tar.gz` :
    os === "openbsd" && arch.endsWith("32") ?
      `hugo_${version}_OpenBSD-32bit.tar.gz` :
    os === "openbsd" && arch === "arm" ?
      `hugo_${version}_OpenBSD-ARM.tar.gz` :
    os === "openbsd" && arch === "arm64" ?
      `hugo_${version}_OpenBSD-ARM64.tar.gz` :

    // not gonna work :(
    null;

  return filename;
}

module.exports.installHugo = installHugo;