@jsenv/https-local 3.0.6 → 3.1.0

package/src/internal/mac/mac_keychain.js

@@ -1,31 +1,30 @@
 // https://ss64.com/osx/security.html
 
-import { fileURLToPath } from "node:url"
-import { createDetailedMessage, UNICODE } from "@jsenv/log"
-
-import { exec } from "../exec.js"
-import { searchCertificateInCommandOutput } from "../search_certificate_in_command_output.js"
+import { createDetailedMessage, UNICODE } from "@jsenv/humanize";
+import { fileURLToPath } from "node:url";
+import { exec } from "../exec.js";
+import { searchCertificateInCommandOutput } from "../search_certificate_in_command_output.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_IN_KEYCHAIN = "certificate not found in mac keychain"
-const REASON_IN_KEYCHAIN = "certificate found in mac keychain"
+  "certificate is new and tryToTrust is disabled";
+const REASON_NOT_IN_KEYCHAIN = "certificate not found in mac keychain";
+const REASON_IN_KEYCHAIN = "certificate found in mac keychain";
 const REASON_ADD_TO_KEYCHAIN_COMMAND_FAILED =
-  "command to add certificate in mac keychain failed"
+  "command to add certificate in mac keychain failed";
 const REASON_ADD_TO_KEYCHAIN_COMMAND_COMPLETED =
-  "command to add certificate in mac keychain completed"
+  "command to add certificate in mac keychain completed";
 const REASON_REMOVE_FROM_KEYCHAIN_COMMAND_FAILED =
-  "command to remove certificate from mac keychain failed"
+  "command to remove certificate from mac keychain failed";
 const REASON_REMOVE_FROM_KEYCHAIN_COMMAND_COMPLETED =
-  "command to remove certificate from mac keychain completed"
+  "command to remove certificate from mac keychain completed";
 
-const systemKeychainPath = "/Library/Keychains/System.keychain"
+const systemKeychainPath = "/Library/Keychains/System.keychain";
 
 export const executeTrustQueryOnMacKeychain = async ({
   logger,
@@ -36,35 +35,35 @@ export const executeTrustQueryOnMacKeychain = async ({
   verb,
 }) => {
   if (verb === VERB_CHECK_TRUST && certificateIsNew) {
-    logger.info(`${UNICODE.INFO} You should add certificate to mac keychain`)
+    logger.info(`${UNICODE.INFO} You should add certificate to mac keychain`);
     return {
       status: "not_trusted",
       reason: REASON_NEW_AND_TRY_TO_TRUST_DISABLED,
-    }
+    };
   }
 
-  logger.info(`Check if certificate is in mac keychain...`)
+  logger.info(`Check if certificate is in mac keychain...`);
   // https://ss64.com/osx/security-find-cert.html
-  const findCertificateCommand = `security find-certificate -a -p ${systemKeychainPath}`
-  logger.debug(`${UNICODE.COMMAND} ${findCertificateCommand}`)
-  const findCertificateCommandOutput = await exec(findCertificateCommand)
+  const findCertificateCommand = `security find-certificate -a -p ${systemKeychainPath}`;
+  logger.debug(`${UNICODE.COMMAND} ${findCertificateCommand}`);
+  const findCertificateCommandOutput = await exec(findCertificateCommand);
   const certificateFoundInCommandOutput = searchCertificateInCommandOutput(
     findCertificateCommandOutput,
     certificate,
-  )
+  );
 
   const removeCert = async () => {
     // https://ss64.com/osx/security-delete-cert.html
-    const removeTrustedCertCommand = `sudo security delete-certificate -c "${certificateCommonName}"`
-    logger.info(`Removing certificate from mac keychain...`)
-    logger.info(`${UNICODE.COMMAND} ${removeTrustedCertCommand}`)
+    const removeTrustedCertCommand = `sudo security delete-certificate -c "${certificateCommonName}"`;
+    logger.info(`Removing certificate from mac keychain...`);
+    logger.info(`${UNICODE.COMMAND} ${removeTrustedCertCommand}`);
     try {
-      await exec(removeTrustedCertCommand)
-      logger.info(`${UNICODE.OK} certificate removed from mac keychain`)
+      await exec(removeTrustedCertCommand);
+      logger.info(`${UNICODE.OK} certificate removed from mac keychain`);
       return {
         status: "not_trusted",
         reason: REASON_REMOVE_FROM_KEYCHAIN_COMMAND_COMPLETED,
-      }
+      };
     } catch (e) {
       logger.error(
         createDetailedMessage(
@@ -74,41 +73,41 @@ export const executeTrustQueryOnMacKeychain = async ({
             "certificate file url": certificateFileUrl,
           },
         ),
-      )
+      );
       return {
         status: "not_trusted",
         reason: REASON_REMOVE_FROM_KEYCHAIN_COMMAND_FAILED,
-      }
+      };
     }
-  }
+  };
 
   if (!certificateFoundInCommandOutput) {
-    logger.info(`${UNICODE.INFO} certificate not found in mac keychain`)
+    logger.info(`${UNICODE.INFO} certificate not found in mac keychain`);
     if (verb === VERB_CHECK_TRUST || verb === VERB_REMOVE_TRUST) {
       return {
         status: "not_trusted",
         reason: REASON_NOT_IN_KEYCHAIN,
-      }
+      };
     }
     if (verb === VERB_ENSURE_TRUST) {
       // It seems possible for certificate PEM representation to be different
       // in mackeychain and in the one we have written on the filesystem
       // When it happens the certificate is not found but actually exists on mackeychain
       // and must be deleted first
-      await removeCert()
+      await removeCert();
     }
-    const certificateFilePath = fileURLToPath(certificateFileUrl)
+    const certificateFilePath = fileURLToPath(certificateFileUrl);
     // https://ss64.com/osx/security-cert.html
-    const addTrustedCertCommand = `sudo security add-trusted-cert -d -r trustRoot -k ${systemKeychainPath} "${certificateFilePath}"`
-    logger.info(`Adding certificate to mac keychain...`)
-    logger.info(`${UNICODE.COMMAND} ${addTrustedCertCommand}`)
+    const addTrustedCertCommand = `sudo security add-trusted-cert -d -r trustRoot -k ${systemKeychainPath} "${certificateFilePath}"`;
+    logger.info(`Adding certificate to mac keychain...`);
+    logger.info(`${UNICODE.COMMAND} ${addTrustedCertCommand}`);
     try {
-      await exec(addTrustedCertCommand)
-      logger.info(`${UNICODE.OK} certificate added to mac keychain`)
+      await exec(addTrustedCertCommand);
+      logger.info(`${UNICODE.OK} certificate added to mac keychain`);
       return {
         status: "trusted",
         reason: REASON_ADD_TO_KEYCHAIN_COMMAND_COMPLETED,
-      }
+      };
     } catch (e) {
       logger.error(
         createDetailedMessage(
@@ -118,11 +117,11 @@ export const executeTrustQueryOnMacKeychain = async ({
             "certificate file": certificateFilePath,
           },
         ),
-      )
+      );
       return {
         status: "not_trusted",
         reason: REASON_ADD_TO_KEYCHAIN_COMMAND_FAILED,
-      }
+      };
     }
   }
 
@@ -130,7 +129,7 @@ export const executeTrustQueryOnMacKeychain = async ({
   // people can still manually untrust the root cert
   // but they shouldn't and I couldn't find an API to know if the cert is trusted or not
   // just if it's in the keychain
-  logger.info(`${UNICODE.OK} certificate found in mac keychain`)
+  logger.info(`${UNICODE.OK} certificate found in mac keychain`);
   if (
     verb === VERB_CHECK_TRUST ||
     verb === VERB_ADD_TRUST ||
@@ -139,8 +138,8 @@ export const executeTrustQueryOnMacKeychain = async ({
     return {
       status: "trusted",
       reason: REASON_IN_KEYCHAIN,
-    }
+    };
   }
 
-  return removeCert()
-}
+  return removeCert();
+};

package/src/internal/mac/nss_mac.js

@@ -1,37 +1,36 @@
-import { fileURLToPath } from "node:url"
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { UNICODE } from "@jsenv/log"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { UNICODE } from "@jsenv/humanize";
+import { fileURLToPath } from "node:url";
+import { commandExists } from "../command.js";
+import { exec } from "../exec.js";
+import { memoize } from "../memoize.js";
 
-import { memoize } from "../memoize.js"
-import { exec } from "../exec.js"
-import { commandExists } from "../command.js"
-
-export const nssCommandName = "nss"
+export const nssCommandName = "nss";
 
 export const detectIfNSSIsInstalled = async ({ logger }) => {
-  logger.debug(`Detecting if nss is installed....`)
-  const brewListCommand = `brew list --versions nss`
+  logger.debug(`Detecting if nss is installed....`);
+  const brewListCommand = `brew list --versions nss`;
 
   try {
-    await exec(brewListCommand)
-    logger.debug(`${UNICODE.OK} nss is installed`)
-    return true
-  } catch (e) {
-    logger.debug(`${UNICODE.INFO} nss not installed`)
-    return false
+    await exec(brewListCommand);
+    logger.debug(`${UNICODE.OK} nss is installed`);
+    return true;
+  } catch {
+    logger.debug(`${UNICODE.INFO} nss not installed`);
+    return false;
   }
-}
+};
 
 export const getCertutilBinPath = memoize(async () => {
-  const brewCommand = `brew --prefix nss`
-  const brewCommandOutput = await exec(brewCommand)
+  const brewCommand = `brew --prefix nss`;
+  const brewCommandOutput = await exec(brewCommand);
   const nssCommandDirectoryUrl = assertAndNormalizeDirectoryUrl(
     brewCommandOutput.trim(),
-  )
-  const certutilBinUrl = new URL(`./bin/certutil`, nssCommandDirectoryUrl).href
-  const certutilBinPath = fileURLToPath(certutilBinUrl)
-  return certutilBinPath
-})
+  );
+  const certutilBinUrl = new URL(`./bin/certutil`, nssCommandDirectoryUrl).href;
+  const certutilBinPath = fileURLToPath(certutilBinUrl);
+  return certutilBinPath;
+});
 
 export const getNSSDynamicInstallInfo = () => {
   return {
@@ -39,12 +38,12 @@ export const getNSSDynamicInstallInfo = () => {
     notInstallableReason: `"brew" is not available`,
     suggestion: `install "brew" on this mac`,
     install: async ({ logger }) => {
-      const brewInstallCommand = `brew install nss`
+      const brewInstallCommand = `brew install nss`;
       logger.info(
         `"nss" is not installed, trying to install "nss" via Homebrew`,
-      )
-      logger.info(`${UNICODE.COMMAND} ${brewInstallCommand}`)
-      await exec(brewInstallCommand)
+      );
+      logger.info(`${UNICODE.COMMAND} ${brewInstallCommand}`);
+      await exec(brewInstallCommand);
     },
-  }
-}
+  };
+};

package/src/internal/mac/safari.js

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

package/src/internal/memoize.js

@@ -1,24 +1,24 @@
 export const memoize = (compute) => {
-  let memoized = false
-  let memoizedValue
+  let memoized = false;
+  let memoizedValue;
 
   const fnWithMemoization = (...args) => {
     if (memoized) {
-      return memoizedValue
+      return memoizedValue;
     }
     // if compute is recursive wait for it to be fully done before storing the lockValue
     // so set locked later
-    memoizedValue = compute(...args)
-    memoized = true
-    return memoizedValue
-  }
+    memoizedValue = compute(...args);
+    memoized = true;
+    return memoizedValue;
+  };
 
   fnWithMemoization.forget = () => {
-    const value = memoizedValue
-    memoized = false
-    memoizedValue = undefined
-    return value
-  }
+    const value = memoizedValue;
+    memoized = false;
+    memoizedValue = undefined;
+    return value;
+  };
 
-  return fnWithMemoization
-}
+  return fnWithMemoization;
+};