@jsenv/https-local 1.0.1 → 1.0.6

package/README.md

@@ -30,7 +30,11 @@ 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,
@@ -38,13 +42,13 @@ await installCertificateAuthority({
 })
 await verifyHostsFile({
   ipMappings: {
-    "127.0.0.1": ["localhost", "local.example.com"],
+    "127.0.0.1": ["localhost"],
   },
   tryToUpdatesHostsFile: true,
 })
 ```
 
-3 - Install certificate authority
+3 - Run file to install certificate authority with node
 
 ```console
 node ./install_certificate_authority.mjs
@@ -55,7 +59,7 @@ node ./install_certificate_authority.mjs
 ```js
 /*
  * This file uses "@jsenv/https-local" to obtain a certificate used to start a server in https.
- * The certificate is valid for 396 days and is issued by a certificate authority trusted on this machine.
+ * The certificate is valid for 1 year (396 days) and is issued by a certificate authority trusted on this machine.
  * If the certificate authority was not installed before executing this file, an error is thrown
  * explaining that certificate authority must be installed first.
  *
@@ -65,12 +69,12 @@ node ./install_certificate_authority.mjs
  *
  * Read more in https://github.com/jsenv/https-local#requestCertificateForLocalhost
  */
+
 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(
   {
@@ -91,12 +95,15 @@ server.listen(8080)
 console.log(`Server listening at https://local.example:8080`)
 ```
 
-5 - Start your server
+5 - Run file to start server with node
 
 ```console
 node ./start_dev_server.mjs
 ```
 
+At this stage of the documentation you have a server running in https.
+The rest of the documentation goes into details.
+
 # Certificate expiration
 
 The server certificate expires after one year which is the maximum duration allowed by web browsers.
@@ -105,7 +112,7 @@ In the unlikely scenario where your local server is running for more than a year
 
 The authority root certificate expires after 20 years which is close to the maximum allowed duration.
 
-In the very unlikely scenario where you are using the same machine for more than 20 years, re-execute [installCertificateAuthority](#installCertificateAuthority) to update certificate authority and restart your server.
+In the very unlikely scenario where you are using the same machine for more than 20 years, re-execute [installCertificateAuthority](#installCertificateAuthority) to update certificate authority then restart your server.
 
 # installCertificateAuthority
 
@@ -118,6 +125,11 @@ import { installCertificateAuthority } from "@jsenv/https-local"
 await installCertificateAuthority()
 ```
 
+By default, trusting authority root certificate is a manual process.
+This manual process is documented in [BenMorel/dev-certificates#Import the CA in your browser](https://github.com/BenMorel/dev-certificates/tree/c10cd68945da772f31815b7a36721ddf848ff3a3#import-the-ca-in-your-browser).
+
+Trusting the root certificate can also be done programmatically as explained in [Auto trust](#Auto-trust).
+
 Find below logs written in terminal when this function is executed.
 
 <details>
@@ -216,11 +228,6 @@ Check if certificate is trusted by firefox...
 
 </details>
 
-By default, trusting authority root certificate is a manual process.
-This manual process is documented in [BenMorel/dev-certificates#Import the CA in your browser](https://github.com/BenMorel/dev-certificates/tree/c10cd68945da772f31815b7a36721ddf848ff3a3#import-the-ca-in-your-browser).
-
-Trusting the root certificate can also be done programmatically as explained the next part.
-
 ## Auto trust
 
 It's possible to trust root certificate programmatically using _tryToTrust_
@@ -269,7 +276,7 @@ Check if certificate is in Firefox...
 </details>
 
 <details>
-  <summary>windows</summary>
+  <summary>linux</summary>
 
 ```console
 > node ./install_certificate_authority.mjs
@@ -280,7 +287,7 @@ Checking certificate validity...
 Detect if certificate attributes have changed...
 ✔ certificate attributes are the same
 Check if certificate is in linux...
-ℹ certificate in linux is outdated
+ℹ certificate not in linux
 Adding certificate to linux...
 ❯ sudo /bin/cp -f "/home/dmail/.config/https_local/https_local_root_certificate.crt" /usr/local/share/ca-certificates/https_local_root_certificate.crt
 [sudo] Password for dmail :
@@ -329,11 +336,11 @@ Detect if certificate attributes have changed...
 ✔ certificate attributes are the same
 Check if certificate is trusted by windows...
 ℹ certificate not trusted by windows
-Check if certificate is trusted by firefox...
-ℹ unable to detect if certificate is trusted by firefox (not implemented on windows)
 Adding certificate to windows...
 ❯ certutil -addstore -user root C:\Users\Dmail\AppData\Local\https_local\https_local_root_certificate.crt
 ✔ certificate added to windows
+Check if certificate is trusted by firefox...
+ℹ unable to detect if certificate is trusted by firefox (not implemented on windows)
 ```
 
 _second execution logs_
@@ -354,16 +361,33 @@ Check if certificate is trusted by firefox...
 
 </details>
 
+# requestCertificateForLocalhost
+
+_requestCertificateForLocalhost_ function returns a certificate and private key that can be used to start a server in HTTPS.
+
+```js
+import { createServer } from "node:https"
+import { requestCertificateForLocalhost } from "@jsenv/https-local"
+
+const { serverCertificate, serverCertificatePrivateKey } =
+  await requestCertificateForLocalhost({
+    serverCertificateAltNames: ["localhost", "local.example"],
+  })
+```
+
+[installCertificateAuthority](#installCertificateAuthority) must be called before this function.
+
 # verifyHostsFile
 
-_verifyHostsFile_ function check your hosts file content to see if ip mappings are present.
+This function is not mandatory to obtain the https certificates.
+But it is useful to programmatically verify ip mappings that are important for your local server are present in hosts file.
 
 ```js
 import { verifyHostsFile } from "@jsenv/https-local"
 
 await verifyHostsFile({
   ipMappings: {
-    "127.0.0.1": ["localhost", "local.example.com"],
+    "127.0.0.1": ["localhost", "local.example"],
   },
 })
 ```
@@ -381,7 +405,7 @@ Check hosts file content...
 --- hosts file path ---
 /etc/hosts
 --- line(s) to add ---
-127.0.0.1 localhost local.example.com
+127.0.0.1 localhost local.example
 ```
 
 </details>
@@ -397,7 +421,7 @@ Check hosts file content...
 --- hosts file path ---
 C:\\Windows\\System32\\Drivers\\etc\\hosts
 --- line(s) to add ---
-127.0.0.1 localhost local.example.com
+127.0.0.1 localhost local.example
 ```
 
 </details>
@@ -411,7 +435,7 @@ import { verifyHostsFile } from "@jsenv/https-local"
 
 await verifyHostsFile({
   ipMappings: {
-    "127.0.0.1": ["localhost", "local.example.com"],
+    "127.0.0.1": ["localhost", "local.example"],
   },
   tryToUpdateHostsFile: true,
 })
@@ -424,7 +448,7 @@ await verifyHostsFile({
 Check hosts file content...
 ℹ 1 mapping is missing in hosts file
 Adding 1 mapping(s) in hosts file...
-❯ echo "127.0.0.1 local.example.com" | sudo tee /etc/hosts
+❯ echo "127.0.0.1 local.example" | sudo tee -a /etc/hosts
 Password:
 ✔ mappings added to hosts file
 ```
@@ -447,7 +471,7 @@ Check hosts file content...
 Check hosts file content...
 ℹ 1 mapping is missing in hosts file
 Adding 1 mapping(s) in hosts file...
-❯ (echo 127.0.0.1 local.example.com) >> C:\\Windows\\System32\\Drivers\\etc\\hosts
+❯ (echo 127.0.0.1 local.example) >> C:\\Windows\\System32\\Drivers\\etc\\hosts
 Password:
 ✔ mappings added to hosts file
 ```
@@ -462,36 +486,3 @@ Check hosts file content...
 ```
 
 </details>
-
-# requestCertificateForLocalhost
-
-_requestCertificateForLocalhost_ function returns a certificate and private key that can be used to start a server in HTTPS.
-
-```js
-import { createServer } from "node:https"
-import { requestCertificateForLocalhost } from "@jsenv/https-local"
-
-const { serverCertificate, serverCertificatePrivateKey } = await requestCertificateForLocalhost({
-  serverCertificateAltNames: ["localhost", "local.example.com"],
-})
-
-const server = createServer(
-  {
-    cert: serverCertificate,
-    key: serverCertificatePrivateKey,
-  },
-  (request, response) => {
-    const body = "Hello world"
-    response.writeHead(200, {
-      "content-type": "text/plain",
-      "content-length": Buffer.byteLength(body),
-    })
-    response.write(body)
-    response.end()
-  },
-)
-server.listen(8080)
-console.log(`Server listening at https://localhost:8080`)
-```
-
-[installCertificateAuthority](#installCertificateAuthority) must be called before this function.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/https-local",
-  "version": "1.0.1",
+  "version": "1.0.6",
   "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

@@ -15,7 +15,7 @@ export const requestCertificateForLocalhost = async ({
   logLevel,
   logger = createLogger({ logLevel }), // to be able to catch logs during unit tests
 
-  serverCertificateAltNames = [],
+  serverCertificateAltNames = ["localhost"],
   serverCertificateCommonName = "https local server certificate",
   serverCertificateValidityDurationInMs = createValidityDurationOfXDays(396),
 } = {}) => {
@@ -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: {