@jsenv/https-local 3.0.7 → 3.1.1

package/src/internal/unsupported_platform/unsupported_platform.js

@@ -1,15 +1,15 @@
-import { UNICODE } from "@jsenv/log"
+import { UNICODE } from "@jsenv/humanize";
 
 const platformTrustInfo = {
   status: "unknown",
   reason: "unsupported platform",
-}
+};
 
 export const executeTrustQuery = ({ logger }) => {
   logger.warn(
     `${UNICODE.WARNING} platform not supported, cannot execute trust query`,
-  )
+  );
   return {
     platform: platformTrustInfo,
-  }
-}
+  };
+};

package/src/internal/validity_formatting.js

@@ -1,8 +1,8 @@
 export const formatStillValid = ({ certificateName, validityRemainingMs }) => {
   return `${certificateName} still valid for ${formatDuration(
     validityRemainingMs,
-  )}`
-}
+  )}`;
+};
 
 export const formatAboutToExpire = ({
   certificateName,
@@ -11,8 +11,8 @@ export const formatAboutToExpire = ({
 }) => {
   return `${certificateName} will expire ${formatTimeDelta(
     validityRemainingMs,
-  )}, it was valid during ${formatDuration(msEllapsedSinceValid)}`
-}
+  )}, it was valid during ${formatDuration(msEllapsedSinceValid)}`;
+};
 
 export const formatExpired = ({
   certificateName,
@@ -21,59 +21,59 @@ export const formatExpired = ({
 }) => {
   return `${certificateName} has expired ${formatTimeDelta(
     -msEllapsedSinceExpiration,
-  )}, it was valid during ${formatDuration(validityDurationInMs)}`
-}
+  )}, it was valid during ${formatDuration(validityDurationInMs)}`;
+};
 
 export const formatTimeDelta = (deltaInMs) => {
-  const unit = pickUnit(Math.abs(deltaInMs))
-  const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" })
-  const msRounded = unit.min ? Math.floor(deltaInMs / unit.min) : deltaInMs
-  return rtf.format(msRounded, unit.name)
-}
+  const unit = pickUnit(Math.abs(deltaInMs));
+  const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+  const msRounded = unit.min ? Math.floor(deltaInMs / unit.min) : deltaInMs;
+  return rtf.format(msRounded, unit.name);
+};
 
 export const formatDuration = (ms) => {
-  const unit = pickUnit(ms)
-  const rtf = new Intl.RelativeTimeFormat("en", { numeric: "always" })
-  const msRounded = unit.min ? Math.floor(ms / unit.min) : ms
-  const parts = rtf.formatToParts(msRounded, unit.name)
+  const unit = pickUnit(ms);
+  const rtf = new Intl.RelativeTimeFormat("en", { numeric: "always" });
+  const msRounded = unit.min ? Math.floor(ms / unit.min) : ms;
+  const parts = rtf.formatToParts(msRounded, unit.name);
   if (parts.length > 1 && parts[0].type === "literal") {
     return parts
       .slice(1)
       .map((part) => part.value)
-      .join("")
+      .join("");
   }
-  return parts.map((part) => part.value).join("")
-}
+  return parts.map((part) => part.value).join("");
+};
 
 const pickUnit = (ms) => {
-  const msPerSecond = 1000
-  const msPerMinute = msPerSecond * 60
-  const msPerHour = msPerMinute * 60
-  const msPerDay = msPerHour * 24
-  const msPerMonth = msPerDay * 30
-  const msPerYear = msPerDay * 365
+  const msPerSecond = 1000;
+  const msPerMinute = msPerSecond * 60;
+  const msPerHour = msPerMinute * 60;
+  const msPerDay = msPerHour * 24;
+  const msPerMonth = msPerDay * 30;
+  const msPerYear = msPerDay * 365;
 
   if (ms < msPerSecond) {
     return {
       name: "second",
       // min 0 to allow display of 0.01 second for example
       min: 0,
-    }
+    };
   }
   if (ms < msPerMinute) {
-    return { name: "second", min: msPerSecond }
+    return { name: "second", min: msPerSecond };
   }
   if (ms < msPerHour) {
-    return { name: "minute", min: msPerMinute }
+    return { name: "minute", min: msPerMinute };
   }
   if (ms < msPerDay) {
-    return { name: "hour", min: msPerHour }
+    return { name: "hour", min: msPerHour };
   }
   if (ms < msPerMonth) {
-    return { name: "day", min: msPerDay }
+    return { name: "day", min: msPerDay };
   }
   if (ms < msPerYear) {
-    return { name: "month", min: msPerMonth }
+    return { name: "month", min: msPerMonth };
   }
-  return { name: "year", min: msPerYear }
-}
+  return { name: "year", min: msPerYear };
+};

package/src/internal/windows/chrome_windows.js

@@ -1,37 +1,36 @@
-import { createRequire } from "node:module"
-import { existsSync } from "node:fs"
-import { UNICODE } from "@jsenv/log"
+import { UNICODE } from "@jsenv/humanize";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { memoize } from "../memoize.js";
 
-import { memoize } from "../memoize.js"
+const require = createRequire(import.meta.url);
 
-const require = createRequire(import.meta.url)
+const which = require("which");
 
-const which = require("which")
-
-const REASON_CHROME_NOT_DETECTED = `Chrome not detected`
+const REASON_CHROME_NOT_DETECTED = `Chrome not detected`;
 
 export const executeTrustQueryOnChrome = ({ logger, windowsTrustInfo }) => {
-  const chromeDetected = detectChrome({ logger })
+  const chromeDetected = detectChrome({ logger });
   if (!chromeDetected) {
     return {
       status: "other",
       reason: REASON_CHROME_NOT_DETECTED,
-    }
+    };
   }
 
   return {
     status: windowsTrustInfo.status,
     reason: windowsTrustInfo.reason,
-  }
-}
+  };
+};
 
 // https://github.com/litixsoft/karma-detect-browsers/blob/332b4bdb2ab3db7c6a1a6d3ec5a1c6ccf2332c4d/browsers/Chrome.js#L1
 const detectChrome = memoize(({ logger }) => {
-  logger.debug(`Detecting Chrome...`)
+  logger.debug(`Detecting Chrome...`);
 
   if (process.env.CHROME_BIN && which.sync(process.env.CHROME_BIN)) {
-    logger.debug(`${UNICODE.OK} Chrome detected`)
-    return true
+    logger.debug(`${UNICODE.OK} Chrome detected`);
+    return true;
   }
 
   const executableCandidates = [
@@ -39,24 +38,24 @@ const detectChrome = memoize(({ logger }) => {
     `${process.env.ProgramW6432}\\Google\\Chrome\\Application\\chrome.exe`,
     `${process.env.ProgramFiles}\\Google\\Chrome\\Application\\chrome.exe`,
     `${process.env["ProgramFiles(x86)"]}\\Google\\Chrome\\Application\\chrome.exe`,
-  ]
+  ];
   const someExecutableFound = executableCandidates.some(
     (chromeExecutablePathCandidate) => {
       if (existsSync(chromeExecutablePathCandidate)) {
-        return true
+        return true;
       }
       try {
-        which.sync(chromeExecutablePathCandidate)
-        return true
-      } catch (e) {}
-      return false
+        which.sync(chromeExecutablePathCandidate);
+        return true;
+      } catch {}
+      return false;
     },
-  )
+  );
   if (someExecutableFound) {
-    logger.debug(`${UNICODE.OK} Chrome detected`)
-    return true
+    logger.debug(`${UNICODE.OK} Chrome detected`);
+    return true;
   }
 
-  logger.debug(`${UNICODE.OK} Chrome detected`)
-  return false
-})
+  logger.debug(`${UNICODE.OK} Chrome detected`);
+  return false;
+});

package/src/internal/windows/edge.js

@@ -2,5 +2,5 @@ export const executeTrustQueryOnEdge = ({ windowsTrustInfo }) => {
   return {
     status: windowsTrustInfo.status,
     reason: windowsTrustInfo.reason,
-  }
-}
+  };
+};

package/src/internal/windows/firefox_windows.js

@@ -3,53 +3,52 @@
  * - A way to install and use NSS command on windows to update firefox NSS dabatase file
  */
 
-import { createRequire } from "node:module"
-import { existsSync } from "node:fs"
-import { UNICODE } from "@jsenv/log"
+import { UNICODE } from "@jsenv/humanize";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { memoize } from "../memoize.js";
 
-import { memoize } from "../memoize.js"
+const require = createRequire(import.meta.url);
 
-const require = createRequire(import.meta.url)
+const which = require("which");
 
-const which = require("which")
-
-const REASON_FIREFOX_NOT_DETECTED = "Firefox not detected"
-const REASON_NOT_IMPLEMENTED_ON_WINDOWS = "not implemented on windows"
+const REASON_FIREFOX_NOT_DETECTED = "Firefox not detected";
+const REASON_NOT_IMPLEMENTED_ON_WINDOWS = "not implemented on windows";
 
 export const executeTrustQueryOnFirefox = ({ logger, certificateIsNew }) => {
-  const firefoxDetected = detectFirefox({ logger })
+  const firefoxDetected = detectFirefox({ logger });
   if (!firefoxDetected) {
     return {
       status: "other",
       reason: REASON_FIREFOX_NOT_DETECTED,
-    }
+    };
   }
 
   if (certificateIsNew) {
-    logger.info(`${UNICODE.INFO} You should add certificate to firefox`)
+    logger.info(`${UNICODE.INFO} You should add certificate to firefox`);
     return {
       status: "not_trusted",
       reason: "certificate is new and tryToTrust is disabled",
-    }
+    };
   }
 
-  logger.info(`Check if certificate is in firefox...`)
+  logger.info(`Check if certificate is in firefox...`);
   logger.info(
     `${UNICODE.INFO} cannot check if certificate is in firefox (${REASON_NOT_IMPLEMENTED_ON_WINDOWS})`,
-  )
+  );
   return {
     status: "unknown",
     reason: REASON_NOT_IMPLEMENTED_ON_WINDOWS,
-  }
-}
+  };
+};
 
 // https://github.com/litixsoft/karma-detect-browsers
 const detectFirefox = memoize(({ logger }) => {
-  logger.debug(`Detecting Firefox...`)
+  logger.debug(`Detecting Firefox...`);
 
   if (process.env.FIREFOX_BIN && which.sync(process.env.FIREFOX_BIN)) {
-    logger.debug(`${UNICODE.OK} Firefox detected`)
-    return true
+    logger.debug(`${UNICODE.OK} Firefox detected`);
+    return true;
   }
 
   const executableCandidates = [
@@ -57,24 +56,24 @@ const detectFirefox = memoize(({ logger }) => {
     `${process.env.ProgramW6432}\\Mozilla Firefox\\firefox.exe`,
     `${process.env.ProgramFiles}\\Mozilla Firefox\\firefox.exe`,
     `${process.env["ProgramFiles(x86)"]}\\Mozilla Firefox\\firefox.exe`,
-  ]
+  ];
   const someExecutableFound = executableCandidates.some(
     (firefoxExecutablePathCandidate) => {
       if (existsSync(firefoxExecutablePathCandidate)) {
-        return true
+        return true;
       }
       try {
-        which.sync(firefoxExecutablePathCandidate)
-        return true
-      } catch (e) {}
-      return false
+        which.sync(firefoxExecutablePathCandidate);
+        return true;
+      } catch {}
+      return false;
     },
-  )
+  );
   if (someExecutableFound) {
-    logger.debug(`${UNICODE.OK} Firefox detected`)
-    return true
+    logger.debug(`${UNICODE.OK} Firefox detected`);
+    return true;
   }
 
-  logger.debug(`${UNICODE.INFO} Firefox detected`)
-  return false
-})
+  logger.debug(`${UNICODE.INFO} Firefox detected`);
+  return false;
+});

package/src/internal/windows/windows.js

@@ -4,10 +4,10 @@
  * - https://www.unix.com/man-page/mojave/1/security/
  */
 
-import { executeTrustQueryOnWindows } from "./windows_certutil.js"
-import { executeTrustQueryOnChrome } from "./chrome_windows.js"
-import { executeTrustQueryOnEdge } from "./edge.js"
-import { executeTrustQueryOnFirefox } from "./firefox_windows.js"
+import { executeTrustQueryOnChrome } from "./chrome_windows.js";
+import { executeTrustQueryOnEdge } from "./edge.js";
+import { executeTrustQueryOnFirefox } from "./firefox_windows.js";
+import { executeTrustQueryOnWindows } from "./windows_certutil.js";
 
 export const executeTrustQuery = async ({
   logger,
@@ -24,26 +24,26 @@ export const executeTrustQuery = async ({
     certificateIsNew,
     certificate,
     verb,
-  })
+  });
 
   const chromeTrustInfo = await executeTrustQueryOnChrome({
     logger,
     windowsTrustInfo,
-  })
+  });
 
   const edgeTrustInfo = await executeTrustQueryOnEdge({
     windowsTrustInfo,
-  })
+  });
 
   const firefoxTrustInfo = await executeTrustQueryOnFirefox({
     logger,
     certificateIsNew,
-  })
+  });
 
   return {
     windows: windowsTrustInfo,
     chrome: chromeTrustInfo,
     edge: edgeTrustInfo,
     firefox: firefoxTrustInfo,
-  }
-}
+  };
+};

package/src/internal/windows/windows_certutil.js

@@ -3,29 +3,28 @@
  * https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certutil
  */
 
-import { fileURLToPath } from "node:url"
-import { createDetailedMessage, UNICODE } from "@jsenv/log"
-
-import { exec } from "../exec.js"
+import { createDetailedMessage, UNICODE } from "@jsenv/humanize";
+import { fileURLToPath } from "node:url";
+import { exec } from "../exec.js";
 import {
-  VERB_CHECK_TRUST,
   VERB_ADD_TRUST,
+  VERB_CHECK_TRUST,
   VERB_ENSURE_TRUST,
   VERB_REMOVE_TRUST,
-} from "../trust_query.js"
+} from "../trust_query.js";
 
 const REASON_NEW_AND_TRY_TO_TRUST_DISABLED =
-  "certificate is new and tryToTrust is disabled"
-const REASON_NOT_FOUND_IN_WINDOWS = "not found in windows store"
-const REASON_FOUND_IN_WINDOWS = "found in windows store"
+  "certificate is new and tryToTrust is disabled";
+const REASON_NOT_FOUND_IN_WINDOWS = "not found in windows store";
+const REASON_FOUND_IN_WINDOWS = "found in windows store";
 const REASON_ADD_COMMAND_FAILED =
-  "command to add certificate to windows store failed"
+  "command to add certificate to windows store failed";
 const REASON_ADD_COMMAND_COMPLETED =
-  "command to add certificate to windows store completed"
+  "command to add certificate to windows store completed";
 const REASON_DELETE_COMMAND_FAILED =
-  "command to remove certificate from windows store failed"
+  "command to remove certificate from windows store failed";
 const REASON_DELETE_COMMAND_COMPLETED =
-  "command to remove certificate from windows store completed"
+  "command to remove certificate from windows store completed";
 
 export const executeTrustQueryOnWindows = async ({
   logger,
@@ -36,46 +35,46 @@ export const executeTrustQueryOnWindows = async ({
   verb,
 }) => {
   if (verb === VERB_CHECK_TRUST && certificateIsNew) {
-    logger.info(`${UNICODE.INFO} You should add certificate to windows`)
+    logger.info(`${UNICODE.INFO} You should add certificate to windows`);
     return {
       status: "not_trusted",
       reason: REASON_NEW_AND_TRY_TO_TRUST_DISABLED,
-    }
+    };
   }
 
-  logger.info(`Check if certificate is in windows...`)
+  logger.info(`Check if certificate is in windows...`);
   // https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certutil#-viewstore
   // TODO: check if -viewstore works better than -store
-  const certutilListCommand = `certutil -store -user root`
-  logger.debug(`${UNICODE.COMMAND} ${certutilListCommand}`)
-  const certutilListCommandOutput = await exec(certutilListCommand)
-  const certificateFilePath = fileURLToPath(certificateFileUrl)
+  const certutilListCommand = `certutil -store -user root`;
+  logger.debug(`${UNICODE.COMMAND} ${certutilListCommand}`);
+  const certutilListCommandOutput = await exec(certutilListCommand);
+  const certificateFilePath = fileURLToPath(certificateFileUrl);
 
   // it's not super accurate and do not take into account if the cert is different
   // but it's the best I could do with certutil command on windows
   const certificateInStore = certutilListCommandOutput.includes(
     certificateCommonName,
-  )
+  );
   if (!certificateInStore) {
-    logger.info(`${UNICODE.INFO} certificate not found in windows`)
+    logger.info(`${UNICODE.INFO} certificate not found in windows`);
     if (verb === VERB_CHECK_TRUST || verb === VERB_REMOVE_TRUST) {
       return {
         status: "not_trusted",
         reason: REASON_NOT_FOUND_IN_WINDOWS,
-      }
+      };
     }
 
     // https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certutil#-addstore
-    const certutilAddCommand = `certutil -addstore -user root "${certificateFilePath}"`
-    logger.info(`Adding certificate to windows...`)
-    logger.info(`${UNICODE.COMMAND} ${certutilAddCommand}`)
+    const certutilAddCommand = `certutil -addstore -user root "${certificateFilePath}"`;
+    logger.info(`Adding certificate to windows...`);
+    logger.info(`${UNICODE.COMMAND} ${certutilAddCommand}`);
     try {
-      await exec(certutilAddCommand)
-      logger.info(`${UNICODE.OK} certificate added to windows`)
+      await exec(certutilAddCommand);
+      logger.info(`${UNICODE.OK} certificate added to windows`);
       return {
         status: "trusted",
         reason: REASON_ADD_COMMAND_COMPLETED,
-      }
+      };
     } catch (e) {
       logger.error(
         createDetailedMessage(
@@ -85,15 +84,15 @@ export const executeTrustQueryOnWindows = async ({
             "certificate file": certificateFilePath,
           },
         ),
-      )
+      );
       return {
         status: "not_trusted",
         reason: REASON_ADD_COMMAND_FAILED,
-      }
+      };
     }
   }
 
-  logger.info(`${UNICODE.OK} certificate found in windows`)
+  logger.info(`${UNICODE.OK} certificate found in windows`);
   if (
     verb === VERB_CHECK_TRUST ||
     verb === VERB_ADD_TRUST ||
@@ -102,20 +101,20 @@ export const executeTrustQueryOnWindows = async ({
     return {
       status: "trusted",
       reason: REASON_FOUND_IN_WINDOWS,
-    }
+    };
   }
 
   // https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certutil#-delstore
-  const certutilRemoveCommand = `certutil -delstore -user root "${certificateCommonName}"`
-  logger.info(`Removing certificate from windows...`)
-  logger.info(`${UNICODE.COMMAND} ${certutilRemoveCommand}`)
+  const certutilRemoveCommand = `certutil -delstore -user root "${certificateCommonName}"`;
+  logger.info(`Removing certificate from windows...`);
+  logger.info(`${UNICODE.COMMAND} ${certutilRemoveCommand}`);
   try {
-    await exec(certutilRemoveCommand)
-    logger.info(`${UNICODE.OK} certificate removed from windows`)
+    await exec(certutilRemoveCommand);
+    logger.info(`${UNICODE.OK} certificate removed from windows`);
     return {
       status: "not_trusted",
       reason: REASON_DELETE_COMMAND_COMPLETED,
-    }
+    };
   } catch (e) {
     logger.error(
       createDetailedMessage(
@@ -125,10 +124,10 @@ export const executeTrustQueryOnWindows = async ({
           "certificate file": certificateFilePath,
         },
       ),
-    )
+    );
     return {
       status: "unknown", // maybe it was not trusted?
       reason: REASON_DELETE_COMMAND_FAILED,
-    }
+    };
   }
-}
+};

package/src/jsenvParameters.js

@@ -1,9 +1,9 @@
-import { createValidityDurationOfXYears } from "./validity_duration.js"
+import { createValidityDurationOfXYears } from "./validity_duration.js";
 
 export const jsenvParameters = {
   certificateCommonName: "https local root certificate",
   certificateValidityDurationInMs: createValidityDurationOfXYears(20),
-}
+};
 
 // const jsenvCertificateParams = {
 //   rootCertificateOrganizationName: "jsenv",

package/src/main.js

@@ -11,13 +11,10 @@
 export {
   installCertificateAuthority,
   uninstallCertificateAuthority,
-} from "./certificate_authority.js"
-
+} from "./certificate_authority.js";
+export { requestCertificate } from "./certificate_request.js";
+export { verifyHostsFile } from "./hosts_file_verif.js";
 export {
-  createValidityDurationOfXYears,
   createValidityDurationOfXDays,
-} from "./validity_duration.js"
-
-export { verifyHostsFile } from "./hosts_file_verif.js"
-
-export { requestCertificate } from "./certificate_request.js"
+  createValidityDurationOfXYears,
+} from "./validity_duration.js";

package/src/validity_duration.js

@@ -1,8 +1,8 @@
-const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000
-const MILLISECONDS_PER_YEAR = MILLISECONDS_PER_DAY * 365
+const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+const MILLISECONDS_PER_YEAR = MILLISECONDS_PER_DAY * 365;
 
 export const verifyRootCertificateValidityDuration = (validityDurationInMs) => {
-  const durationInYears = validityDurationInMs / MILLISECONDS_PER_YEAR
+  const durationInYears = validityDurationInMs / MILLISECONDS_PER_YEAR;
   if (durationInYears > 25) {
     return {
       ok: false,
@@ -10,15 +10,15 @@ export const verifyRootCertificateValidityDuration = (validityDurationInMs) => {
       message: `root certificate validity duration of ${durationInYears} years is too much, using the max recommended duration: 25 years`,
       details:
         "https://serverfault.com/questions/847190/in-theory-could-a-ca-make-a-certificate-that-is-valid-for-arbitrarily-long",
-    }
+    };
   }
-  return { ok: true }
-}
+  return { ok: true };
+};
 
 export const verifyServerCertificateValidityDuration = (
   validityDurationInMs,
 ) => {
-  const validityDurationInDays = validityDurationInMs / MILLISECONDS_PER_DAY
+  const validityDurationInDays = validityDurationInMs / MILLISECONDS_PER_DAY;
   if (validityDurationInDays > 397) {
     return {
       ok: false,
@@ -26,13 +26,13 @@ export const verifyServerCertificateValidityDuration = (
       message: `certificate validity duration of ${validityDurationInMs} days is too much, using the max recommended duration: 397 days`,
       details:
         "https://www.globalsign.com/en/blog/maximum-ssltls-certificate-validity-now-one-year",
-    }
+    };
   }
-  return { ok: true }
-}
+  return { ok: true };
+};
 
 export const createValidityDurationOfXYears = (years) =>
-  MILLISECONDS_PER_YEAR * years + 5000
+  MILLISECONDS_PER_YEAR * years + 5000;
 
 export const createValidityDurationOfXDays = (days) =>
-  MILLISECONDS_PER_DAY * days + 5000
+  MILLISECONDS_PER_DAY * days + 5000;