@jsenv/https-local 1.0.2 → 1.0.7

package/README.md

@@ -31,7 +31,10 @@ npm install --save-dev @jsenv/https-local
  * Read more in https://github.com/jsenv/https-local#installCertificateAuthority
  */
 
-import { installCertificateAuthority, verifyHostsFile } from "@jsenv/https-local"
+import {
+  installCertificateAuthority,
+  verifyHostsFile,
+} from "@jsenv/https-local"
 
 await installCertificateAuthority({
   tryToTrust: true,
@@ -39,7 +42,7 @@ await installCertificateAuthority({
 })
 await verifyHostsFile({
   ipMappings: {
-    "127.0.0.1": ["localhost", "local.example"],
+    "127.0.0.1": ["localhost"],
   },
   tryToUpdatesHostsFile: true,
 })
@@ -70,9 +73,8 @@ node ./install_certificate_authority.mjs
 import { createServer } from "node:https"
 import { requestCertificateForLocalhost } from "@jsenv/https-local"
 
-const { serverCertificate, serverCertificatePrivateKey } = await requestCertificateForLocalhost({
-  serverCertificateAltNames: ["localhost", "local.example"],
-})
+const { serverCertificate, serverCertificatePrivateKey } =
+  await requestCertificateForLocalhost()
 
 const server = createServer(
   {
@@ -367,9 +369,10 @@ _requestCertificateForLocalhost_ function returns a certificate and private key
 import { createServer } from "node:https"
 import { requestCertificateForLocalhost } from "@jsenv/https-local"
 
-const { serverCertificate, serverCertificatePrivateKey } = await requestCertificateForLocalhost({
-  serverCertificateAltNames: ["localhost", "local.example"],
-})
+const { serverCertificate, serverCertificatePrivateKey } =
+  await requestCertificateForLocalhost({
+    serverCertificateAltNames: ["localhost", "local.example"],
+  })
 ```
 
 [installCertificateAuthority](#installCertificateAuthority) must be called before this function.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/https-local",
-  "version": "1.0.2",
+  "version": "1.0.7",
   "description": "A programmatic way to generate locally trusted certificates",
   "license": "MIT",
   "author": {
@@ -13,11 +13,10 @@
     "url": "https://github.com/jsenv/https-local"
   },
   "engines": {
-    "node": ">=14.17.0"
+    "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "exports": {
@@ -26,14 +25,17 @@
     },
     "./*": "./*"
   },
+  "main": "./main.js",
   "files": [
     "/src/",
     "/main.js"
   ],
   "scripts": {
-    "eslint-check": "node ./node_modules/eslint/bin/eslint.js .",
-    "generate-importmap": "node ./script/importmap/generate_importmap.mjs",
-    "measure-performances": "node ./script/performance/generate_performance_report.mjs --local",
+    "eslint": "node ./node_modules/eslint/bin/eslint.js . --ext=.js,.mjs",
+    "importmap": "node ./script/importmap/importmap.mjs",
+    "performances": "node --expose-gc ./script/performance/generate_performance_report.mjs --log",
+    "test": "node ./script/test/test.mjs",
+    "test-with-coverage": "npm run test -- --coverage",
     "start-node-server": "node ./script/certificate/start_node_server.mjs",
     "log-root-certificate-trust": "node ./script/certificate/log_root_certificate_trust.mjs",
     "trust-root-certificate": "node ./script/certificate/trust_root_certificate.mjs",
@@ -43,39 +45,31 @@
     "remove-localhost-mappings": "node ./script/hosts/remove_localhost_mappings.mjs",
     "verify-localhost-mappings": "node ./script/hosts/verify_localhost_mappings.mjs",
     "ensure-localhost-mappings": "node ./script/hosts/ensure_localhost_mappings.mjs",
-    "test": "node ./script/test/test.mjs",
-    "test-with-coverage": "npm run test -- --coverage",
-    "prettier-format": "node ./script/prettier/prettier_format.mjs",
-    "prettier-format-stage": "npm run prettier-format -- --staged",
-    "prettier-check": "npm run prettier-format -- --dry-run",
-    "install-playwright": "npx playwright install-deps && npx playwright install",
-    "prepublishOnly": "node ./script/publish/remove_postinstall.mjs",
-    "postpublish": "node ./script/publish/restore_postinstall.mjs"
+    "prettier": "prettier --write .",
+    "playwright-install": "npx playwright install-deps && npx playwright install"
   },
   "dependencies": {
-    "@jsenv/filesystem": "2.1.1",
+    "@jsenv/filesystem": "2.7.1",
     "@jsenv/logger": "4.0.1",
     "command-exists": "1.2.9",
     "is-unicode-supported": "1.1.0",
-    "node-forge": "0.10.0",
+    "node-forge": "1.2.1",
     "sudo-prompt": "9.2.1",
-    "supports-color": "9.0.2",
+    "supports-color": "9.2.1",
     "which": "2.0.2"
   },
   "devDependencies": {
-    "@jsenv/assert": "2.3.0",
-    "@jsenv/codecov-upload": "3.5.0",
-    "@jsenv/core": "19.6.2",
-    "@jsenv/eslint-config": "15.0.2",
-    "@jsenv/github-release-package": "1.2.3",
-    "@jsenv/importmap-eslint-resolver": "5.1.0",
-    "@jsenv/importmap-node-module": "1.0.1",
-    "@jsenv/package-publish": "1.6.2",
-    "@jsenv/performance-impact": "1.7.0",
-    "@jsenv/prettier-check-project": "5.6.1",
-    "eslint": "7.32.0",
-    "eslint-plugin-import": "2.24.0",
-    "playwright": "1.14.0",
-    "prettier": "2.3.2"
+    "@jsenv/assert": "2.4.1",
+    "@jsenv/core": "25.3.0",
+    "@jsenv/eslint-config": "16.0.9",
+    "@jsenv/github-release-package": "1.3.3",
+    "@jsenv/importmap-eslint-resolver": "5.2.5",
+    "@jsenv/importmap-node-module": "5.1.3",
+    "@jsenv/package-publish": "1.7.2",
+    "@jsenv/performance-impact": "2.2.4",
+    "eslint": "8.7.0",
+    "eslint-plugin-import": "2.25.4",
+    "playwright": "1.18.0",
+    "prettier": "2.5.1"
   }
-}
+}

package/src/certificate_authority.js

@@ -1,12 +1,13 @@
-/* eslint-disable import/max-dependencies */
-
-import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import { readFile, writeFile, removeFileSystemNode } from "@jsenv/filesystem"
+import { createLogger, createDetailedMessage } from "@jsenv/logger"
 
 import { infoSign, okSign } from "./internal/logs.js"
 import { getAuthorityFileInfos } from "./internal/authority_file_infos.js"
 import { attributeDescriptionFromAttributeArray } from "./internal/certificate_data_converter.js"
-import { formatTimeDelta, formatDuration } from "./internal/validity_formatting.js"
+import {
+  formatTimeDelta,
+  formatDuration,
+} from "./internal/validity_formatting.js"
 import { importNodeForge } from "./internal/forge.js"
 import { createAuthorityRootCertificate } from "./internal/certificate_generator.js"
 import { importPlatformMethods } from "./internal/platform.js"
@@ -54,8 +55,11 @@ export const installCertificateAuthority = async ({
     )
   }
 
-  const { authorityJsonFileInfo, rootCertificateFileInfo, rootCertificatePrivateKeyFileInfo } =
-    getAuthorityFileInfos()
+  const {
+    authorityJsonFileInfo,
+    rootCertificateFileInfo,
+    rootCertificatePrivateKeyFileInfo,
+  } = getAuthorityFileInfos()
   const authorityJsonFileUrl = authorityJsonFileInfo.url
   const rootCertificateFileUrl = rootCertificateFileInfo.url
   const rootPrivateKeyFileUrl = rootCertificatePrivateKeyFileInfo.url
@@ -76,16 +80,23 @@ export const installCertificateAuthority = async ({
       })
 
     const { pki } = await importNodeForge()
-    const rootCertificate = pemAsFileContent(pki.certificateToPem(rootCertificateForgeObject))
+    const rootCertificate = pemAsFileContent(
+      pki.certificateToPem(rootCertificateForgeObject),
+    )
     const rootCertificatePrivateKey = pemAsFileContent(
       pki.privateKeyToPem(rootCertificatePrivateKeyForgeObject),
     )
 
     await writeFile(rootCertificateFileUrl, rootCertificate)
     await writeFile(rootPrivateKeyFileUrl, rootCertificatePrivateKey)
-    await writeFile(authorityJsonFileUrl, JSON.stringify({ serialNumber: 0 }, null, "  "))
+    await writeFile(
+      authorityJsonFileUrl,
+      JSON.stringify({ serialNumber: 0 }, null, "  "),
+    )
 
-    logger.info(`${okSign} authority root certificate written at ${rootCertificateFileInfo.path}`)
+    logger.info(
+      `${okSign} authority root certificate written at ${rootCertificateFileInfo.path}`,
+    )
     return {
       rootCertificateForgeObject,
       rootCertificatePrivateKeyForgeObject,
@@ -140,14 +151,18 @@ export const installCertificateAuthority = async ({
     logger.debug(
       `Authority root certificate is not on filesystem at ${rootCertificateFileInfo.path}`,
     )
-    logger.info(`${infoSign} authority root certificate not found in filesystem`)
+    logger.info(
+      `${infoSign} authority root certificate not found in filesystem`,
+    )
     return generate()
   }
   if (!rootCertificatePrivateKeyFileInfo.exists) {
     logger.debug(
       `Authority root certificate private key is not on filesystem at ${rootCertificatePrivateKeyFileInfo.path}`,
     )
-    logger.info(`${infoSign} authority root certificate not found in filesystem`)
+    logger.info(
+      `${infoSign} authority root certificate not found in filesystem`,
+    )
     return generate()
   }
   logger.debug(
@@ -155,18 +170,23 @@ export const installCertificateAuthority = async ({
   )
   logger.info(`${okSign} authority root certificate found in filesystem`)
 
-  const rootCertificate = await readFile(rootCertificateFileInfo.path, { as: "string" })
+  const rootCertificate = await readFile(rootCertificateFileInfo.path, {
+    as: "string",
+  })
   const { pki } = await importNodeForge()
   const rootCertificateForgeObject = pki.certificateFromPem(rootCertificate)
 
   logger.info(`Checking certificate validity...`)
-  const rootCertificateValidityDurationInMs = getCertificateValidityDurationInMs(
+  const rootCertificateValidityDurationInMs =
+    getCertificateValidityDurationInMs(rootCertificateForgeObject)
+  const rootCertificateValidityRemainingMs = getCertificateRemainingMs(
     rootCertificateForgeObject,
   )
-  const rootCertificateValidityRemainingMs = getCertificateRemainingMs(rootCertificateForgeObject)
   if (rootCertificateValidityRemainingMs < 0) {
     logger.info(
-      `${infoSign} certificate expired ${formatTimeDelta(rootCertificateValidityRemainingMs)}`,
+      `${infoSign} certificate expired ${formatTimeDelta(
+        rootCertificateValidityRemainingMs,
+      )}`,
     )
     return regenerate()
   }
@@ -174,30 +194,44 @@ export const installCertificateAuthority = async ({
     rootCertificateValidityRemainingMs / rootCertificateValidityDurationInMs
   if (rootCertificateValidityRemainingRatio < aboutToExpireRatio) {
     logger.info(
-      `${infoSign} certificate will expire ${formatTimeDelta(rootCertificateValidityRemainingMs)}`,
+      `${infoSign} certificate will expire ${formatTimeDelta(
+        rootCertificateValidityRemainingMs,
+      )}`,
     )
     return regenerate()
   }
   logger.info(
-    `${okSign} certificate still valid for ${formatDuration(rootCertificateValidityRemainingMs)}`,
+    `${okSign} certificate still valid for ${formatDuration(
+      rootCertificateValidityRemainingMs,
+    )}`,
   )
 
   logger.info(`Detect if certificate attributes have changed...`)
-  const rootCertificateDifferences = compareRootCertificateAttributes(rootCertificateForgeObject, {
-    certificateCommonName,
-    certificateValidityDurationInMs,
-  })
+  const rootCertificateDifferences = compareRootCertificateAttributes(
+    rootCertificateForgeObject,
+    {
+      certificateCommonName,
+      certificateValidityDurationInMs,
+    },
+  )
   if (rootCertificateDifferences.length) {
     const paramNames = Object.keys(rootCertificateDifferences)
-    logger.info(`${infoSign} certificate attributes are outdated: ${paramNames}`)
+    logger.info(
+      `${infoSign} certificate attributes are outdated: ${paramNames}`,
+    )
     return regenerate()
   }
   logger.info(`${okSign} certificate attributes are the same`)
 
-  const rootCertificatePrivateKey = await readFile(rootCertificatePrivateKeyFileInfo.path, {
-    as: "string",
-  })
-  const rootCertificatePrivateKeyForgeObject = pki.privateKeyFromPem(rootCertificatePrivateKey)
+  const rootCertificatePrivateKey = await readFile(
+    rootCertificatePrivateKeyFileInfo.path,
+    {
+      as: "string",
+    },
+  )
+  const rootCertificatePrivateKeyForgeObject = pki.privateKeyFromPem(
+    rootCertificatePrivateKey,
+  )
 
   const trustInfo = await platformMethods.executeTrustQuery({
     logger,
@@ -272,8 +306,11 @@ export const uninstallCertificateAuthority = async ({
   logger = createLogger({ logLevel }),
   tryToUntrust = false,
 } = {}) => {
-  const { authorityJsonFileInfo, rootCertificateFileInfo, rootCertificatePrivateKeyFileInfo } =
-    getAuthorityFileInfos()
+  const {
+    authorityJsonFileInfo,
+    rootCertificateFileInfo,
+    rootCertificatePrivateKeyFileInfo,
+  } = getAuthorityFileInfos()
 
   const filesToRemove = []
 
@@ -283,7 +320,9 @@ export const uninstallCertificateAuthority = async ({
   if (rootCertificateFileInfo.exists) {
     // first untrust the root cert file
     if (tryToUntrust) {
-      const rootCertificate = await readFile(rootCertificateFileInfo.url, { as: "string" })
+      const rootCertificate = await readFile(rootCertificateFileInfo.url, {
+        as: "string",
+      })
       const { pki } = await importNodeForge()
       const rootCertificateForgeObject = pki.certificateFromPem(rootCertificate)
       const rootCertificateCommonName = attributeDescriptionFromAttributeArray(

package/src/certificate_for_localhost.js

@@ -41,8 +41,11 @@ export const requestCertificateForLocalhost = async ({
     )
   }
 
-  const { authorityJsonFileInfo, rootCertificateFileInfo, rootCertificatePrivateKeyFileInfo } =
-    getAuthorityFileInfos()
+  const {
+    authorityJsonFileInfo,
+    rootCertificateFileInfo,
+    rootCertificatePrivateKeyFileInfo,
+  } = getAuthorityFileInfos()
   if (!rootCertificateFileInfo.exists) {
     throw new Error(
       `Certificate authority not found, "installCertificateAuthority" must be called before "requestCertificateForLocalhost"`,
@@ -57,16 +60,26 @@ export const requestCertificateForLocalhost = async ({
 
   logger.debug(`Restoring certificate authority from filesystem...`)
   const { pki } = await importNodeForge()
-  const rootCertificate = await readFile(rootCertificateFileInfo.url, { as: "string" })
-  const rootCertificatePrivateKey = await readFile(rootCertificatePrivateKeyFileInfo.url, {
+  const rootCertificate = await readFile(rootCertificateFileInfo.url, {
     as: "string",
   })
-  const certificateAuthorityData = await readFile(authorityJsonFileInfo.url, { as: "json" })
+  const rootCertificatePrivateKey = await readFile(
+    rootCertificatePrivateKeyFileInfo.url,
+    {
+      as: "string",
+    },
+  )
+  const certificateAuthorityData = await readFile(authorityJsonFileInfo.url, {
+    as: "json",
+  })
   const rootCertificateForgeObject = pki.certificateFromPem(rootCertificate)
-  const rootCertificatePrivateKeyForgeObject = pki.privateKeyFromPem(rootCertificatePrivateKey)
+  const rootCertificatePrivateKeyForgeObject = pki.privateKeyFromPem(
+    rootCertificatePrivateKey,
+  )
   logger.debug(`${okSign} certificate authority restored from filesystem`)
 
-  const serverCertificateSerialNumber = certificateAuthorityData.serialNumber + 1
+  const serverCertificateSerialNumber =
+    certificateAuthorityData.serialNumber + 1
   await writeFile(
     authorityJsonFileInfo.url,
     JSON.stringify({ serialNumber: serverCertificateSerialNumber }, null, "  "),
@@ -81,14 +94,17 @@ export const requestCertificateForLocalhost = async ({
     await requestCertificateFromAuthority({
       logger,
       authorityCertificateForgeObject: rootCertificateForgeObject,
-      auhtorityCertificatePrivateKeyForgeObject: rootCertificatePrivateKeyForgeObject,
+      auhtorityCertificatePrivateKeyForgeObject:
+        rootCertificatePrivateKeyForgeObject,
       serialNumber: serverCertificateSerialNumber,
       altNames: serverCertificateAltNames,
       commonName: serverCertificateCommonName,
       validityDurationInMs: serverCertificateValidityDurationInMs,
     })
   const serverCertificate = pki.certificateToPem(certificateForgeObject)
-  const serverCertificatePrivateKey = pki.privateKeyToPem(certificatePrivateKeyForgeObject)
+  const serverCertificatePrivateKey = pki.privateKeyToPem(
+    certificatePrivateKeyForgeObject,
+  )
   logger.debug(
     `${okSign} server certificate generated, it will be valid for ${formatDuration(
       serverCertificateValidityDurationInMs,

package/src/hosts_file_verif.js

@@ -24,7 +24,9 @@ export const verifyHostsFile = async ({
   Object.keys(ipMappings).forEach((ip) => {
     const ipHostnames = ipMappings[ip]
     if (!Array.isArray(ipHostnames)) {
-      throw new TypeError(`ipMappings values must be an array, found ${ipHostnames} for ${ip}`)
+      throw new TypeError(
+        `ipMappings values must be an array, found ${ipHostnames} for ${ip}`,
+      )
     }
     const existingMappings = hostnames.getIpHostnames(ip)
     const missingHostnames = normalizeHostnames(ipHostnames).filter(
@@ -47,15 +49,20 @@ export const verifyHostsFile = async ({
       .map(({ ip, missingHostnames }) => `${ip} ${missingHostnames.join(" ")}`)
       .join(EOL)
     logger.warn(
-      createDetailedMessage(`${warningSign} ${formatXMappingMissingMessage(missingMappingCount)}`, {
-        "hosts file path": hostsFilePath,
-        "line(s) to add": linesToAdd,
-      }),
+      createDetailedMessage(
+        `${warningSign} ${formatXMappingMissingMessage(missingMappingCount)}`,
+        {
+          "hosts file path": hostsFilePath,
+          "line(s) to add": linesToAdd,
+        },
+      ),
     )
     return
   }
 
-  logger.info(`${infoSign} ${formatXMappingMissingMessage(missingMappingCount)}`)
+  logger.info(
+    `${infoSign} ${formatXMappingMissingMessage(missingMappingCount)}`,
+  )
   await missingMappings.reduce(async (previous, { ip, missingHostnames }) => {
     await previous
     const mapping = `${ip} ${missingHostnames.join(" ")}`

package/src/internal/authority_file_infos.js

@@ -11,14 +11,20 @@ export const getAuthorityFileInfos = () => {
     rootCertificatePrivateKeyFileUrl,
   } = getCertificateAuthorityFileUrls()
 
-  const authorityJsonFilePath = urlToFileSystemPath(certificateAuthorityJsonFileUrl)
+  const authorityJsonFilePath = urlToFileSystemPath(
+    certificateAuthorityJsonFileUrl,
+  )
   const authorityJsonFileDetected = existsSync(authorityJsonFilePath)
 
   const rootCertificateFilePath = urlToFileSystemPath(rootCertificateFileUrl)
   const rootCertificateFileDetected = existsSync(rootCertificateFilePath)
 
-  const rootCertificatePrivateKeyFilePath = urlToFileSystemPath(rootCertificatePrivateKeyFileUrl)
-  const rootCertificatePrivateKeyFileDetected = existsSync(rootCertificatePrivateKeyFilePath)
+  const rootCertificatePrivateKeyFilePath = urlToFileSystemPath(
+    rootCertificatePrivateKeyFileUrl,
+  )
+  const rootCertificatePrivateKeyFileDetected = existsSync(
+    rootCertificatePrivateKeyFilePath,
+  )
 
   return {
     authorityJsonFileInfo: {

package/src/internal/certificate_authority_file_urls.js

@@ -1,4 +1,8 @@
-import { assertAndNormalizeDirectoryUrl, resolveUrl, urlToFilename } from "@jsenv/filesystem"
+import {
+  assertAndNormalizeDirectoryUrl,
+  resolveUrl,
+  urlToFilename,
+} from "@jsenv/filesystem"
 
 export const getCertificateAuthorityFileUrls = () => {
   // we need a directory common to every instance of @jsenv/https-local
@@ -36,9 +40,15 @@ export const getRootCertificateSymlinkUrls = ({
   const serverCertificateDirectory = resolveUrl("./", serverCertificateFileUrl)
 
   const rootCertificateFilename = urlToFilename(rootCertificateFileUrl)
-  const rootCertificateSymlinkUrl = resolveUrl(rootCertificateFilename, serverCertificateDirectory)
+  const rootCertificateSymlinkUrl = resolveUrl(
+    rootCertificateFilename,
+    serverCertificateDirectory,
+  )
   const rootPrivateKeyFilename = urlToFilename(rootPrivateKeyFileUrl)
-  const rootPrivateKeySymlinkUrl = resolveUrl(rootPrivateKeyFilename, serverCertificateDirectory)
+  const rootPrivateKeySymlinkUrl = resolveUrl(
+    rootPrivateKeyFilename,
+    serverCertificateDirectory,
+  )
 
   return {
     rootCertificateSymlinkUrl,
@@ -64,12 +74,18 @@ const getJsenvApplicationDirectoryUrl = () => {
         assertAndNormalizeDirectoryUrl(process.env.XDG_CONFIG_HOME),
       )
     }
-    return resolveUrl(`./.config/https_local/`, assertAndNormalizeDirectoryUrl(process.env.HOME))
+    return resolveUrl(
+      `./.config/https_local/`,
+      assertAndNormalizeDirectoryUrl(process.env.HOME),
+    )
   }
 
   if (platform === "win32") {
     if (process.env.LOCALAPPDATA) {
-      return resolveUrl(`./https_local/`, assertAndNormalizeDirectoryUrl(process.env.LOCALAPPDATA))
+      return resolveUrl(
+        `./https_local/`,
+        assertAndNormalizeDirectoryUrl(process.env.LOCALAPPDATA),
+      )
     }
 
     return resolveUrl(

package/src/internal/certificate_data_converter.js

@@ -34,7 +34,9 @@ const isUrl = (value) => {
   }
 }
 
-export const extensionArrayFromExtensionDescription = (extensionDescription) => {
+export const extensionArrayFromExtensionDescription = (
+  extensionDescription,
+) => {
   const extensionArray = []
   Object.keys(extensionDescription).forEach((key) => {
     const value = extensionDescription[key]
@@ -65,7 +67,9 @@ export const attributeDescriptionFromAttributeArray = (attributeArray) => {
   return attributeObject
 }
 
-export const attributeArrayFromAttributeDescription = (attributeDescription) => {
+export const attributeArrayFromAttributeDescription = (
+  attributeDescription,
+) => {
   const attributeArray = []
   Object.keys(attributeDescription).forEach((key) => {
     const value = attributeDescription[key]

package/src/internal/certificate_generator.js

@@ -33,7 +33,9 @@ export const createAuthorityRootCertificate = async ({
   rootCertificateForgeObject.publicKey = rootCertificatePublicKeyForgeObject
   rootCertificateForgeObject.serialNumber = serialNumber.toString(16)
   rootCertificateForgeObject.validity.notBefore = new Date()
-  rootCertificateForgeObject.validity.notAfter = new Date(Date.now() + validityDurationInMs)
+  rootCertificateForgeObject.validity.notAfter = new Date(
+    Date.now() + validityDurationInMs,
+  )
   rootCertificateForgeObject.setSubject(
     attributeArrayFromAttributeDescription({
       commonName,
@@ -109,7 +111,9 @@ export const requestCertificateFromAuthority = async ({
     )
   }
   if (typeof serialNumber !== "number") {
-    throw new TypeError(`serialNumber must be a number but received ${serialNumber}`)
+    throw new TypeError(
+      `serialNumber must be a number but received ${serialNumber}`,
+    )
   }
 
   const forge = await importNodeForge()
@@ -122,16 +126,23 @@ export const requestCertificateFromAuthority = async ({
   certificateForgeObject.publicKey = certificatePublicKeyForgeObject
   certificateForgeObject.serialNumber = serialNumber.toString(16)
   certificateForgeObject.validity.notBefore = new Date()
-  certificateForgeObject.validity.notAfter = new Date(Date.now() + validityDurationInMs)
+  certificateForgeObject.validity.notAfter = new Date(
+    Date.now() + validityDurationInMs,
+  )
 
   const attributeDescription = {
-    ...attributeDescriptionFromAttributeArray(authorityCertificateForgeObject.subject.attributes),
+    ...attributeDescriptionFromAttributeArray(
+      authorityCertificateForgeObject.subject.attributes,
+    ),
     commonName,
     // organizationName: serverCertificateOrganizationName
   }
-  const attributeArray = attributeArrayFromAttributeDescription(attributeDescription)
+  const attributeArray =
+    attributeArrayFromAttributeDescription(attributeDescription)
   certificateForgeObject.setSubject(attributeArray)
-  certificateForgeObject.setIssuer(authorityCertificateForgeObject.subject.attributes)
+  certificateForgeObject.setIssuer(
+    authorityCertificateForgeObject.subject.attributes,
+  )
   certificateForgeObject.setExtensions(
     extensionArrayFromExtensionDescription({
       basicConstraints: {
@@ -159,7 +170,10 @@ export const requestCertificateFromAuthority = async ({
       },
     }),
   )
-  certificateForgeObject.sign(auhtorityCertificatePrivateKeyForgeObject, forge.sha256.create())
+  certificateForgeObject.sign(
+    auhtorityCertificatePrivateKeyForgeObject,
+    forge.sha256.create(),
+  )
 
   return {
     certificateForgeObject,

package/src/internal/command.js

@@ -4,5 +4,6 @@ const require = createRequire(import.meta.url)
 
 export const commandExists = async (command) => {
   const { sync } = require("command-exists")
-  return sync(command)
+  const exists = sync(command)
+  return exists
 }

package/src/internal/exec.js

@@ -1,6 +1,9 @@
 import { exec as nodeExec } from "node:child_process"
 
-export const exec = (command, { cwd, input, onLog = () => {}, onErrorLog = () => {} } = {}) => {
+export const exec = (
+  command,
+  { cwd, input, onLog = () => {}, onErrorLog = () => {} } = {},
+) => {
   return new Promise((resolve, reject) => {
     const commandProcess = nodeExec(
       command,