@jsenv/https-local 1.0.5 → 1.0.8

package/README.md

@@ -1,12 +1,6 @@
-# https local
+# https local [![npm package](https://img.shields.io/npm/v/@jsenv/https-local.svg?logo=npm&label=package)](https://www.npmjs.com/package/@jsenv/https-local)
 
-A programmatic way to generate locally trusted certificates
-
-[![npm package](https://img.shields.io/npm/v/@jsenv/https-local.svg?logo=npm&label=package)](https://www.npmjs.com/package/@jsenv/https-local)
-[![github main](https://github.com/jsenv/https-local/workflows/main/badge.svg)](https://github.com/jsenv/https-local/actions?workflow=main)
-[![codecov coverage](https://codecov.io/gh/jsenv/https-local/branch/main/graph/badge.svg)](https://codecov.io/gh/jsenv/https-local)
-
-# Presentation
+A programmatic way to generate locally trusted certificates.
 
 Generate certificate(s) trusted by your operating system and browsers.
 This certificate can be used to start your development server in HTTPS.
@@ -106,13 +100,14 @@ 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.
+| Certificate | Expires after | How to renew?                           |
+| ----------- | ------------- | --------------------------------------- |
+| server      | 1 year        | Re-run _requestCertificateForLocalhost_ |
+| authority   | 20 year       | Re-run _installCertificateAuthority_    |
 
-In the unlikely scenario where your local server is running for more than a year without interruption, restart it and you're good for one more year.
+The **server** certificate expires after one year which is the maximum duration allowed by web browsers. In the unlikely scenario where your local server is running for more than a year without interruption, restart it and you're good for one more 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 then restart your server.
+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 then restart your server.
 
 # installCertificateAuthority
 
@@ -125,10 +120,7 @@ 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).
+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). This process can be done programmatically as explained in [Auto trust](#Auto-trust).
 
 Find below logs written in terminal when this function is executed.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/https-local",
-  "version": "1.0.5",
+  "version": "1.0.8",
   "description": "A programmatic way to generate locally trusted certificates",
   "license": "MIT",
   "author": {
@@ -31,7 +31,7 @@
     "/main.js"
   ],
   "scripts": {
-    "eslint": "node ./node_modules/eslint/bin/eslint.js . --ext=.js,.mjs",
+    "eslint": "npx eslint . --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",
@@ -49,27 +49,26 @@
     "playwright-install": "npx playwright install-deps && npx playwright install"
   },
   "dependencies": {
-    "@jsenv/filesystem": "2.7.1",
+    "@jsenv/filesystem": "3.1.0",
+    "@jsenv/log": "1.5.1",
     "@jsenv/logger": "4.0.1",
     "command-exists": "1.2.9",
-    "is-unicode-supported": "1.1.0",
-    "node-forge": "1.2.1",
+    "node-forge": "1.3.1",
     "sudo-prompt": "9.2.1",
-    "supports-color": "9.2.1",
     "which": "2.0.2"
   },
   "devDependencies": {
-    "@jsenv/assert": "2.4.1",
-    "@jsenv/core": "25.3.0",
+    "@jsenv/assert": "2.5.3",
+    "@jsenv/core": "26.0.1",
     "@jsenv/eslint-config": "16.0.9",
-    "@jsenv/github-release-package": "1.3.2",
+    "@jsenv/github-release-package": "1.3.5",
     "@jsenv/importmap-eslint-resolver": "5.2.5",
     "@jsenv/importmap-node-module": "5.1.3",
-    "@jsenv/package-publish": "1.7.1",
-    "@jsenv/performance-impact": "2.2.4",
-    "eslint": "8.7.0",
-    "eslint-plugin-import": "2.25.4",
-    "playwright": "1.18.0",
-    "prettier": "2.5.1"
+    "@jsenv/package-publish": "1.7.2",
+    "@jsenv/performance-impact": "2.2.8",
+    "eslint": "8.12.0",
+    "eslint-plugin-import": "2.26.0",
+    "playwright": "1.20.2",
+    "prettier": "2.6.2"
   }
 }

package/src/certificate_authority.js

@@ -1,9 +1,7 @@
-/* eslint-disable import/max-dependencies */
-
+import { readFile, writeFile, removeEntry } from "@jsenv/filesystem"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
-import { readFile, writeFile, removeFileSystemNode } from "@jsenv/filesystem"
+import { UNICODE } from "@jsenv/log"
 
-import { infoSign, okSign } from "./internal/logs.js"
 import { getAuthorityFileInfos } from "./internal/authority_file_infos.js"
 import { attributeDescriptionFromAttributeArray } from "./internal/certificate_data_converter.js"
 import {
@@ -97,7 +95,7 @@ export const installCertificateAuthority = async ({
     )
 
     logger.info(
-      `${okSign} authority root certificate written at ${rootCertificateFileInfo.path}`,
+      `${UNICODE.OK} authority root certificate written at ${rootCertificateFileInfo.path}`,
     )
     return {
       rootCertificateForgeObject,
@@ -154,7 +152,7 @@ export const installCertificateAuthority = async ({
       `Authority root certificate is not on filesystem at ${rootCertificateFileInfo.path}`,
     )
     logger.info(
-      `${infoSign} authority root certificate not found in filesystem`,
+      `${UNICODE.INFO} authority root certificate not found in filesystem`,
     )
     return generate()
   }
@@ -163,14 +161,14 @@ export const installCertificateAuthority = async ({
       `Authority root certificate private key is not on filesystem at ${rootCertificatePrivateKeyFileInfo.path}`,
     )
     logger.info(
-      `${infoSign} authority root certificate not found in filesystem`,
+      `${UNICODE.INFO} authority root certificate not found in filesystem`,
     )
     return generate()
   }
   logger.debug(
     `found authority root certificate files at ${rootCertificateFileInfo.path} and ${rootCertificatePrivateKeyFileInfo.path}`,
   )
-  logger.info(`${okSign} authority root certificate found in filesystem`)
+  logger.info(`${UNICODE.OK} authority root certificate found in filesystem`)
 
   const rootCertificate = await readFile(rootCertificateFileInfo.path, {
     as: "string",
@@ -186,7 +184,7 @@ export const installCertificateAuthority = async ({
   )
   if (rootCertificateValidityRemainingMs < 0) {
     logger.info(
-      `${infoSign} certificate expired ${formatTimeDelta(
+      `${UNICODE.INFO} certificate expired ${formatTimeDelta(
         rootCertificateValidityRemainingMs,
       )}`,
     )
@@ -196,14 +194,14 @@ export const installCertificateAuthority = async ({
     rootCertificateValidityRemainingMs / rootCertificateValidityDurationInMs
   if (rootCertificateValidityRemainingRatio < aboutToExpireRatio) {
     logger.info(
-      `${infoSign} certificate will expire ${formatTimeDelta(
+      `${UNICODE.INFO} certificate will expire ${formatTimeDelta(
         rootCertificateValidityRemainingMs,
       )}`,
     )
     return regenerate()
   }
   logger.info(
-    `${okSign} certificate still valid for ${formatDuration(
+    `${UNICODE.OK} certificate still valid for ${formatDuration(
       rootCertificateValidityRemainingMs,
     )}`,
   )
@@ -219,11 +217,11 @@ export const installCertificateAuthority = async ({
   if (rootCertificateDifferences.length) {
     const paramNames = Object.keys(rootCertificateDifferences)
     logger.info(
-      `${infoSign} certificate attributes are outdated: ${paramNames}`,
+      `${UNICODE.INFO} certificate attributes are outdated: ${paramNames}`,
     )
     return regenerate()
   }
-  logger.info(`${okSign} certificate attributes are the same`)
+  logger.info(`${UNICODE.OK} certificate attributes are the same`)
 
   const rootCertificatePrivateKey = await readFile(
     rootCertificatePrivateKeyFileInfo.path,
@@ -348,10 +346,12 @@ export const uninstallCertificateAuthority = async ({
     logger.info(`Removing certificate authority files...`)
     await Promise.all(
       filesToRemove.map(async (file) => {
-        await removeFileSystemNode(file)
+        await removeEntry(file)
       }),
     )
-    logger.info(`${okSign} certificate authority files removed from filesystem`)
+    logger.info(
+      `${UNICODE.OK} certificate authority files removed from filesystem`,
+    )
   }
 }
 

package/src/certificate_for_localhost.js

@@ -1,11 +1,11 @@
 import { readFile, writeFile } from "@jsenv/filesystem"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
+import { UNICODE } from "@jsenv/log"
 
 import {
   createValidityDurationOfXDays,
   verifyServerCertificateValidityDuration,
 } from "./validity_duration.js"
-import { okSign } from "./internal/logs.js"
 import { getAuthorityFileInfos } from "./internal/authority_file_infos.js"
 import { importNodeForge } from "./internal/forge.js"
 import { requestCertificateFromAuthority } from "./internal/certificate_generator.js"
@@ -76,7 +76,7 @@ export const requestCertificateForLocalhost = async ({
   const rootCertificatePrivateKeyForgeObject = pki.privateKeyFromPem(
     rootCertificatePrivateKey,
   )
-  logger.debug(`${okSign} certificate authority restored from filesystem`)
+  logger.debug(`${UNICODE.OK} certificate authority restored from filesystem`)
 
   const serverCertificateSerialNumber =
     certificateAuthorityData.serialNumber + 1
@@ -106,7 +106,9 @@ export const requestCertificateForLocalhost = async ({
     certificatePrivateKeyForgeObject,
   )
   logger.debug(
-    `${okSign} server certificate generated, it will be valid for ${formatDuration(
+    `${
+      UNICODE.OK
+    } server certificate generated, it will be valid for ${formatDuration(
       serverCertificateValidityDurationInMs,
     )}`,
   )

package/src/hosts_file_verif.js

@@ -1,6 +1,6 @@
 import { createDetailedMessage, createLogger } from "@jsenv/logger"
+import { UNICODE } from "@jsenv/log"
 
-import { okSign, infoSign, warningSign, commandSign } from "./internal/logs.js"
 import {
   HOSTS_FILE_PATH,
   readHostsFile,
@@ -38,7 +38,7 @@ export const verifyHostsFile = async ({
   })
   const missingMappingCount = missingMappings.length
   if (missingMappingCount === 0) {
-    logger.info(`${okSign} all ip mappings found in hosts file`)
+    logger.info(`${UNICODE.OK} all ip mappings found in hosts file`)
     return
   }
 
@@ -50,7 +50,9 @@ export const verifyHostsFile = async ({
       .join(EOL)
     logger.warn(
       createDetailedMessage(
-        `${warningSign} ${formatXMappingMissingMessage(missingMappingCount)}`,
+        `${UNICODE.WARNING} ${formatXMappingMissingMessage(
+          missingMappingCount,
+        )}`,
         {
           "hosts file path": hostsFilePath,
           "line(s) to add": linesToAdd,
@@ -61,7 +63,7 @@ export const verifyHostsFile = async ({
   }
 
   logger.info(
-    `${infoSign} ${formatXMappingMissingMessage(missingMappingCount)}`,
+    `${UNICODE.INFO} ${formatXMappingMissingMessage(missingMappingCount)}`,
   )
   await missingMappings.reduce(async (previous, { ip, missingHostnames }) => {
     await previous
@@ -71,10 +73,10 @@ export const verifyHostsFile = async ({
     await writeLineInHostsFile(mapping, {
       hostsFilePath,
       onBeforeExecCommand: (command) => {
-        logger.info(`${commandSign} ${command}`)
+        logger.info(`${UNICODE.COMMAND} ${command}`)
       },
     })
-    logger.info(`${okSign} mapping added`)
+    logger.info(`${UNICODE.OK} mapping added`)
   }, Promise.resolve())
 }
 

package/src/internal/authority_file_infos.js

@@ -1,5 +1,4 @@
 import { existsSync } from "node:fs"
-
 import { urlToFileSystemPath } from "@jsenv/filesystem"
 
 import { getCertificateAuthorityFileUrls } from "./certificate_authority_file_urls.js"

package/src/internal/hosts/write_line_hosts.js

@@ -29,7 +29,7 @@ const appendToHostsFileOnWindows = async ({
   hostsFilePath,
   onBeforeExecCommand,
 }) => {
-  const hostsFileContent = await readFile(hostsFilePath)
+  const hostsFileContent = await readFile(hostsFilePath, { as: "string" })
   const echoCommand =
     hostsFileContent.length > 0 && !hostsFileContent.endsWith("\r\n")
       ? `(echo.& echo ${lineToAppend})`
@@ -68,7 +68,7 @@ const appendToHostsFileOnLinuxOrMac = async ({
   hostsFilePath,
   onBeforeExecCommand,
 }) => {
-  const hostsFileContent = await readFile(hostsFilePath)
+  const hostsFileContent = await readFile(hostsFilePath, { as: "string" })
   const echoCommand =
     hostsFileContent.length > 0 && !hostsFileContent.endsWith("\n")
       ? `echo "\n${lineToAppend}"`

package/src/internal/linux/chrome_linux.js

@@ -2,11 +2,7 @@ import { existsSync } from "node:fs"
 import { execSync } from "node:child_process"
 import { resolveUrl, assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 
-import {
-  okSign,
-  infoSign,
-  warningSign,
-} from "@jsenv/https-local/src/internal/logs.js"
+import { UNICODE } from "@jsenv/log"
 import {
   nssCommandName,
   detectIfNSSIsInstalled,
@@ -45,11 +41,11 @@ export const executeTrustQueryOnChrome = ({
       const chromeBinFileExists = existsSync("/usr/bin/google-chrome")
 
       if (chromeBinFileExists) {
-        logger.debug(`${okSign} Chrome detected`)
+        logger.debug(`${UNICODE.OK} Chrome detected`)
         return true
       }
 
-      logger.debug(`${infoSign} Chrome not detected`)
+      logger.debug(`${UNICODE.INFO} Chrome not detected`)
       return false
     },
     browserNSSDBDirectoryUrl: resolveUrl(
@@ -62,14 +58,14 @@ export const executeTrustQueryOnChrome = ({
       }
 
       logger.warn(
-        `${warningSign} waiting for you to close Chrome before resuming...`,
+        `${UNICODE.WARNING} waiting for you to close Chrome before resuming...`,
       )
       const next = async () => {
         await new Promise((resolve) => setTimeout(resolve, 50))
         if (isChromeOpen()) {
           await next()
         } else {
-          logger.info(`${okSign} Chrome closed, resuming`)
+          logger.info(`${UNICODE.OK} Chrome closed, resuming`)
           // wait 50ms more to ensure chrome has time to cleanup
           // othrwise sometimes there is an SEC_ERROR_REUSED_ISSUER_AND_SERIAL error
           // because we updated nss database file while chrome is not fully closed

package/src/internal/linux/firefox_linux.js

@@ -1,12 +1,8 @@
 import { existsSync } from "node:fs"
 import { execSync } from "node:child_process"
 import { resolveUrl, assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
+import { UNICODE } from "@jsenv/log"
 
-import {
-  okSign,
-  infoSign,
-  warningSign,
-} from "@jsenv/https-local/src/internal/logs.js"
 import {
   nssCommandName,
   detectIfNSSIsInstalled,
@@ -45,11 +41,11 @@ export const executeTrustQueryOnFirefox = ({
       const firefoxBinFileExists = existsSync("/usr/bin/firefox")
 
       if (firefoxBinFileExists) {
-        logger.debug(`${okSign} Firefox detected`)
+        logger.debug(`${UNICODE.OK} Firefox detected`)
         return true
       }
 
-      logger.debug(`${infoSign} Firefox not detected`)
+      logger.debug(`${UNICODE.INFO} Firefox not detected`)
       return false
     },
     browserNSSDBDirectoryUrl: resolveUrl(
@@ -62,14 +58,14 @@ export const executeTrustQueryOnFirefox = ({
       }
 
       logger.warn(
-        `${warningSign} waiting for you to close Firefox before resuming...`,
+        `${UNICODE.WARNING} waiting for you to close Firefox before resuming...`,
       )
       const next = async () => {
         await new Promise((resolve) => setTimeout(resolve, 50))
         if (isFirefoxOpen()) {
           await next()
         } else {
-          logger.info(`${okSign} Firefox closed, resuming`)
+          logger.info(`${UNICODE.OK} Firefox closed, resuming`)
           // wait 50ms more to ensure firefox has time to cleanup
           // othrwise sometimes there is an SEC_ERROR_REUSED_ISSUER_AND_SERIAL error
           // because we updated nss database file while firefox is not fully closed

package/src/internal/linux/linux_trust_store.js

@@ -5,13 +5,8 @@
 import { existsSync } from "node:fs"
 import { createDetailedMessage } from "@jsenv/logger"
 import { readFile, urlToFileSystemPath } from "@jsenv/filesystem"
+import { UNICODE } from "@jsenv/log"
 
-import {
-  commandSign,
-  okSign,
-  infoSign,
-  failureSign,
-} from "@jsenv/https-local/src/internal/logs.js"
 import { exec } from "@jsenv/https-local/src/internal/exec.js"
 import {
   VERB_CHECK_TRUST,
@@ -44,7 +39,7 @@ export const executeTrustQueryOnLinux = async ({
   verb,
 }) => {
   if (verb === VERB_CHECK_TRUST && certificateIsNew) {
-    logger.info(`${infoSign} You should add certificate to linux`)
+    logger.info(`${UNICODE.INFO} You should add certificate to linux`)
     return {
       status: "not_trusted",
       reason: REASON_NEW_AND_TRY_TO_TRUST_DISABLED,
@@ -60,9 +55,9 @@ export const executeTrustQueryOnLinux = async ({
 
   if (certificateStatus === "missing" || certificateStatus === "outdated") {
     if (certificateStatus === "missing") {
-      logger.info(`${infoSign} certificate not in linux`)
+      logger.info(`${UNICODE.INFO} certificate not in linux`)
     } else {
-      logger.info(`${infoSign} certificate in linux is outdated`)
+      logger.info(`${UNICODE.INFO} certificate in linux is outdated`)
     }
     if (verb === VERB_CHECK_TRUST || verb === VERB_REMOVE_TRUST) {
       return {
@@ -78,11 +73,11 @@ export const executeTrustQueryOnLinux = async ({
     const updateCertificateCommand = `sudo update-ca-certificates`
     logger.info(`Adding certificate to linux...`)
     try {
-      logger.info(`${commandSign} ${copyCertificateCommand}`)
+      logger.info(`${UNICODE.COMMAND} ${copyCertificateCommand}`)
       await exec(copyCertificateCommand)
-      logger.info(`${commandSign} ${updateCertificateCommand}`)
+      logger.info(`${UNICODE.COMMAND} ${updateCertificateCommand}`)
       await exec(updateCertificateCommand)
-      logger.info(`${okSign} certificate added to linux`)
+      logger.info(`${UNICODE.OK} certificate added to linux`)
       return {
         status: "trusted",
         reason: REASON_ADD_COMMAND_COMPLETED,
@@ -91,7 +86,7 @@ export const executeTrustQueryOnLinux = async ({
       console.error(e)
       logger.error(
         createDetailedMessage(
-          `${failureSign} failed to add certificate to linux`,
+          `${UNICODE.FAILURE} failed to add certificate to linux`,
           {
             "certificate file": certificateFilePath,
           },
@@ -104,7 +99,7 @@ export const executeTrustQueryOnLinux = async ({
     }
   }
 
-  logger.info(`${okSign} certificate found in linux`)
+  logger.info(`${UNICODE.OK} certificate found in linux`)
   if (verb === VERB_CHECK_TRUST || verb === VERB_ADD_TRUST) {
     return {
       status: "trusted",
@@ -116,11 +111,11 @@ export const executeTrustQueryOnLinux = async ({
   const removeCertificateCommand = `sudo rm ${JSENV_AUTHORITY_ROOT_CERTIFICATE_PATH}`
   const updateCertificateCommand = `sudo update-ca-certificates`
   try {
-    logger.info(`${commandSign} ${removeCertificateCommand}`)
+    logger.info(`${UNICODE.COMMAND} ${removeCertificateCommand}`)
     await exec(removeCertificateCommand)
-    logger.info(`${commandSign} ${updateCertificateCommand}`)
+    logger.info(`${UNICODE.COMMAND} ${updateCertificateCommand}`)
     await exec(updateCertificateCommand)
-    logger.info(`${okSign} certificate removed from linux`)
+    logger.info(`${UNICODE.OK} certificate removed from linux`)
     return {
       status: "not_trusted",
       reason: REASON_REMOVE_COMMAND_COMPLETED,
@@ -128,7 +123,7 @@ export const executeTrustQueryOnLinux = async ({
   } catch (e) {
     logger.error(
       createDetailedMessage(
-        `${failureSign} failed to remove certificate from linux`,
+        `${UNICODE.FAILURE} failed to remove certificate from linux`,
         {
           "error stack": e.stack,
           "certificate file": JSENV_AUTHORITY_ROOT_CERTIFICATE_PATH,
@@ -149,6 +144,7 @@ const getCertificateStatus = async ({ certificate }) => {
   }
   const certificateInLinuxStore = await readFile(
     JSENV_AUTHORITY_ROOT_CERTIFICATE_PATH,
+    { as: "string" },
   )
   if (certificateInLinuxStore !== certificate) {
     return "outdated"

package/src/internal/linux/nss_linux.js

@@ -1,9 +1,6 @@
+import { UNICODE } from "@jsenv/log"
+
 import { memoize } from "@jsenv/https-local/src/internal/memoize.js"
-import {
-  commandSign,
-  infoSign,
-  okSign,
-} from "@jsenv/https-local/src/internal/logs.js"
 import { exec } from "@jsenv/https-local/src/internal/exec.js"
 
 export const nssCommandName = "libnss3-tools"
@@ -12,15 +9,15 @@ export const detectIfNSSIsInstalled = memoize(async ({ logger }) => {
   logger.debug(`Detect if nss installed....`)
 
   const aptCommand = `apt list libnss3-tools --installed`
-  logger.debug(`${commandSign} ${aptCommand}`)
+  logger.debug(`${UNICODE.COMMAND} ${aptCommand}`)
   const aptCommandOutput = await exec(aptCommand)
 
   if (aptCommandOutput.includes("libnss3-tools")) {
-    logger.debug(`${okSign} libnss3-tools is installed`)
+    logger.debug(`${UNICODE.OK} libnss3-tools is installed`)
     return true
   }
 
-  logger.debug(`${infoSign} libnss3-tools not installed`)
+  logger.debug(`${UNICODE.INFO} libnss3-tools not installed`)
   return false
 })
 
@@ -28,13 +25,13 @@ export const getCertutilBinPath = () => "certutil"
 
 export const getNSSDynamicInstallInfo = ({ logger }) => {
   return {
-    nssIsInstallable: true,
-    nssInstall: async () => {
+    isInstallable: true,
+    install: async () => {
       const aptInstallCommand = `sudo apt install libnss3-tools`
       logger.info(
         `"libnss3-tools" is not installed, trying to install "libnss3-tools"`,
       )
-      logger.info(`${commandSign} ${aptInstallCommand}`)
+      logger.info(`${UNICODE.COMMAND} ${aptInstallCommand}`)
       await exec(aptInstallCommand)
     },
   }

package/src/internal/mac/chrome_mac.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs"
+import { UNICODE } from "@jsenv/log"
 
-import { okSign, infoSign } from "@jsenv/https-local/src/internal/logs.js"
 import { memoize } from "@jsenv/https-local/src/internal/memoize.js"
 
 const REASON_CHROME_NOT_DETECTED = `Chrome not detected`
@@ -25,10 +25,10 @@ const detectChrome = memoize(({ logger }) => {
   const chromeDetected = existsSync("/Applications/Google Chrome.app")
 
   if (chromeDetected) {
-    logger.debug(`${okSign} Chrome detected`)
+    logger.debug(`${UNICODE.OK} Chrome detected`)
     return true
   }
 
-  logger.debug(`${infoSign} Chrome not detected`)
+  logger.debug(`${UNICODE.INFO} Chrome not detected`)
   return false
 })

package/src/internal/mac/firefox_mac.js

@@ -1,12 +1,7 @@
 import { existsSync } from "node:fs"
 import { execSync } from "node:child_process"
 import { resolveUrl, assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-
-import {
-  okSign,
-  infoSign,
-  warningSign,
-} from "@jsenv/https-local/src/internal/logs.js"
+import { UNICODE } from "@jsenv/log"
 
 import { executeTrustQueryOnBrowserNSSDB } from "../nssdb_browser.js"
 import {
@@ -45,11 +40,11 @@ export const executeTrustQueryOnFirefox = ({
       const firefoxDetected = existsSync("/Applications/Firefox.app")
 
       if (firefoxDetected) {
-        logger.debug(`${okSign} firefox detected`)
+        logger.debug(`${UNICODE.OK} firefox detected`)
         return true
       }
 
-      logger.debug(`${infoSign} firefox not detected`)
+      logger.debug(`${UNICODE.INFO} firefox not detected`)
       return false
     },
     browserNSSDBDirectoryUrl: resolveUrl(
@@ -62,14 +57,14 @@ export const executeTrustQueryOnFirefox = ({
       }
 
       logger.warn(
-        `${warningSign} waiting for you to close firefox before resuming...`,
+        `${UNICODE.WARNING} waiting for you to close firefox before resuming...`,
       )
       const next = async () => {
         await new Promise((resolve) => setTimeout(resolve, 50))
         if (isFirefoxOpen()) {
           await next()
         } else {
-          logger.info(`${okSign} firefox closed, resuming`)
+          logger.info(`${UNICODE.OK} firefox closed, resuming`)
           // wait 50ms more to ensure firefox has time to cleanup
           // othrwise sometimes there is an SEC_ERROR_REUSED_ISSUER_AND_SERIAL error
           // because we updated nss database file while firefox is not fully closed

package/src/internal/mac/mac_keychain.js

@@ -3,12 +3,7 @@
 import { urlToFileSystemPath } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
 
-import {
-  commandSign,
-  okSign,
-  infoSign,
-  failureSign,
-} from "@jsenv/https-local/src/internal/logs.js"
+import { UNICODE } from "@jsenv/log"
 import { exec } from "@jsenv/https-local/src/internal/exec.js"
 import { searchCertificateInCommandOutput } from "@jsenv/https-local/src/internal/search_certificate_in_command_output.js"
 import {
@@ -41,7 +36,7 @@ export const executeTrustQueryOnMacKeychain = async ({
   verb,
 }) => {
   if (verb === VERB_CHECK_TRUST && certificateIsNew) {
-    logger.info(`${infoSign} 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,
@@ -51,7 +46,7 @@ export const executeTrustQueryOnMacKeychain = async ({
   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(`${commandSign} ${findCertificateCommand}`)
+  logger.debug(`${UNICODE.COMMAND} ${findCertificateCommand}`)
   const findCertificateCommandOutput = await exec(findCertificateCommand)
   const certificateFoundInCommandOutput = searchCertificateInCommandOutput(
     findCertificateCommandOutput,
@@ -59,7 +54,7 @@ export const executeTrustQueryOnMacKeychain = async ({
   )
 
   if (!certificateFoundInCommandOutput) {
-    logger.info(`${infoSign} 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",
@@ -71,10 +66,10 @@ export const executeTrustQueryOnMacKeychain = async ({
     // 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(`${commandSign} ${addTrustedCertCommand}`)
+    logger.info(`${UNICODE.COMMAND} ${addTrustedCertCommand}`)
     try {
       await exec(addTrustedCertCommand)
-      logger.info(`${okSign} certificate added to mac keychain`)
+      logger.info(`${UNICODE.OK} certificate added to mac keychain`)
       return {
         status: "trusted",
         reason: REASON_ADD_TO_KEYCHAIN_COMMAND_COMPLETED,
@@ -82,7 +77,7 @@ export const executeTrustQueryOnMacKeychain = async ({
     } catch (e) {
       logger.error(
         createDetailedMessage(
-          `${failureSign} failed to add certificate to mac keychain`,
+          `${UNICODE.FAILURE} failed to add certificate to mac keychain`,
           {
             "error stack": e.stack,
             "certificate file": certificateFilePath,
@@ -100,7 +95,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(`${okSign} certificate found in mac keychain`)
+  logger.info(`${UNICODE.OK} certificate found in mac keychain`)
   if (verb === VERB_CHECK_TRUST || verb === VERB_ADD_TRUST) {
     return {
       status: "trusted",
@@ -111,10 +106,10 @@ export const executeTrustQueryOnMacKeychain = 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(`${commandSign} ${removeTrustedCertCommand}`)
+  logger.info(`${UNICODE.COMMAND} ${removeTrustedCertCommand}`)
   try {
     await exec(removeTrustedCertCommand)
-    logger.info(`${okSign} certificate removed from mac keychain`)
+    logger.info(`${UNICODE.OK} certificate removed from mac keychain`)
     return {
       status: "not_trusted",
       reason: REASON_REMOVE_FROM_KEYCHAIN_COMMAND_COMPLETED,
@@ -122,7 +117,7 @@ export const executeTrustQueryOnMacKeychain = async ({
   } catch (e) {
     logger.error(
       createDetailedMessage(
-        `${failureSign} failed to remove certificate from mac keychain`,
+        `${UNICODE.FAILURE} failed to remove certificate from mac keychain`,
         {
           "error stack": e.stack,
           "certificate file url": certificateFileUrl,

package/src/internal/mac/nss_mac.js

@@ -3,10 +3,10 @@ import {
   resolveUrl,
   urlToFileSystemPath,
 } from "@jsenv/filesystem"
+import { UNICODE } from "@jsenv/log"
 
 import { memoize } from "@jsenv/https-local/src/internal/memoize.js"
 import { exec } from "@jsenv/https-local/src/internal/exec.js"
-import { infoSign, okSign } from "@jsenv/https-local/src/internal/logs.js"
 import { commandExists } from "@jsenv/https-local/src/internal/command.js"
 
 export const nssCommandName = "nss"
@@ -17,10 +17,10 @@ export const detectIfNSSIsInstalled = async ({ logger }) => {
 
   try {
     await exec(brewListCommand)
-    logger.debug(`${okSign} nss is installed`)
+    logger.debug(`${UNICODE.OK} nss is installed`)
     return true
   } catch (e) {
-    logger.debug(`${infoSign} nss not installed`)
+    logger.debug(`${UNICODE.INFO} nss not installed`)
     return false
   }
 }
@@ -38,15 +38,15 @@ export const getCertutilBinPath = memoize(async () => {
 
 export const getNSSDynamicInstallInfo = () => {
   return {
-    nssIsInstallable: commandExists("brew"),
-    nssNotInstallableReason: `"brew" is not available`,
-    nssInstallFixSuggestion: `install "brew" on this mac`,
-    installNss: async ({ logger }) => {
+    isInstallable: commandExists("brew"),
+    notInstallableReason: `"brew" is not available`,
+    suggestion: `install "brew" on this mac`,
+    install: async ({ logger }) => {
       const brewInstallCommand = `brew install nss`
       logger.info(
         `"nss" is not installed, trying to install "nss" via Homebrew`,
       )
-      logger.info(`> ${brewInstallCommand}`)
+      logger.info(`${UNICODE.COMMAND} ${brewInstallCommand}`)
       await exec(brewInstallCommand)
     },
   }

package/src/internal/nssdb_browser.js

@@ -12,14 +12,8 @@ import {
   urlToFilename,
   urlToFileSystemPath,
 } from "@jsenv/filesystem"
+import { UNICODE } from "@jsenv/log"
 
-import {
-  commandSign,
-  okSign,
-  infoSign,
-  warningSign,
-  failureSign,
-} from "@jsenv/https-local/src/internal/logs.js"
 import { exec } from "@jsenv/https-local/src/internal/exec.js"
 import { searchCertificateInCommandOutput } from "@jsenv/https-local/src/internal/search_certificate_in_command_output.js"
 import { VERB_CHECK_TRUST, VERB_ADD_TRUST } from "./trust_query.js"
@@ -52,7 +46,7 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
   }
 
   if (verb === VERB_CHECK_TRUST && certificateIsNew) {
-    logger.info(`${infoSign} You should add certificate to ${browserName}`)
+    logger.info(`${UNICODE.INFO} You should add certificate to ${browserName}`)
     return {
       status: "not_trusted",
       reason: "certificate is new and tryToTrust is disabled",
@@ -61,22 +55,18 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
 
   logger.info(`Check if certificate is in ${browserName}...`)
   const nssIsInstalled = await detectIfNSSIsInstalled({ logger })
-  const cannotCheckMessage = `${failureSign} cannot check if certificate is in ${browserName}`
+  const cannotCheckMessage = `${UNICODE.FAILURE} cannot check if certificate is in ${browserName}`
   if (!nssIsInstalled) {
     if (verb === VERB_ADD_TRUST) {
-      const {
-        nssIsInstallable,
-        nssNotInstallableReason,
-        nssInstallFixSuggestion,
-        nssInstall,
-      } = await getNSSDynamicInstallInfo({ logger })
-      if (!nssIsInstallable) {
+      const nssDynamicInstallInfo = await getNSSDynamicInstallInfo({ logger })
+      if (!nssDynamicInstallInfo.isInstallable) {
         const reason = `"${nssCommandName}" is not installed and not cannot be installed`
         logger.warn(
           createDetailedMessage(cannotCheckMessage, {
             reason,
-            "reason it cannot be installed": nssNotInstallableReason,
-            "suggested solution": nssInstallFixSuggestion,
+            "reason it cannot be installed":
+              nssDynamicInstallInfo.notInstallableReason,
+            "suggested solution": nssDynamicInstallInfo.suggestion,
           }),
         )
         return {
@@ -100,7 +90,7 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
       }
 
       try {
-        await nssInstall()
+        await nssDynamicInstallInfo.install({ logger })
       } catch (e) {
         logger.error(
           createDetailedMessage(cannotCheckMessage, {
@@ -148,7 +138,7 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
     const directoryArg = getDirectoryArgFromNSSDBFileUrl(NSSDBFileUrl)
     const certutilListCommand = `${certutilBinPath} -L -a -d ${directoryArg} -n "${certificateCommonName}"`
     logger.debug(`Checking if certificate is in nss database...`)
-    logger.debug(`${commandSign} ${certutilListCommand}`)
+    logger.debug(`${UNICODE.COMMAND} ${certutilListCommand}`)
     try {
       const output = await execCertutilCommmand(certutilListCommand)
       const isInDatabase = searchCertificateInCommandOutput(output, certificate)
@@ -168,18 +158,18 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
     const directoryArg = getDirectoryArgFromNSSDBFileUrl(NSSDBFileUrl)
     const certutilAddCommand = `${certutilBinPath} -A -d ${directoryArg} -t C,, -i "${certificateFilePath}" -n "${certificateCommonName}"`
     logger.debug(`Adding certificate to nss database...`)
-    logger.debug(`${commandSign} ${certutilAddCommand}`)
+    logger.debug(`${UNICODE.COMMAND} ${certutilAddCommand}`)
     await execCertutilCommmand(certutilAddCommand)
-    logger.debug(`${okSign} certificate added to nss database`)
+    logger.debug(`${UNICODE.OK} certificate added to nss database`)
   }
 
   const removeFromNSSDB = async ({ NSSDBFileUrl }) => {
     const directoryArg = getDirectoryArgFromNSSDBFileUrl(NSSDBFileUrl)
     const certutilRemoveCommand = `${certutilBinPath} -D -d ${directoryArg} -t C,, -i "${certificateFilePath}" -n "${certificateCommonName}"`
     logger.debug(`Removing certificate from nss database...`)
-    logger.debug(`${commandSign} ${certutilRemoveCommand}`)
+    logger.debug(`${UNICODE.COMMAND} ${certutilRemoveCommand}`)
     await execCertutilCommmand(certutilRemoveCommand)
-    logger.debug(`${okSign} certificate removed from nss database`)
+    logger.debug(`${UNICODE.OK} certificate removed from nss database`)
   }
 
   const missings = []
@@ -190,7 +180,7 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
       const certificateStatus = await checkNSSDB({ NSSDBFileUrl })
 
       if (certificateStatus === "missing") {
-        logger.debug(`${infoSign} certificate not found in nss database`)
+        logger.debug(`${UNICODE.INFO} certificate not found in nss database`)
         missings.push(NSSDBFileUrl)
         return
       }
@@ -200,7 +190,7 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
         return
       }
 
-      logger.debug(`${okSign} certificate found in nss database`)
+      logger.debug(`${UNICODE.OK} certificate found in nss database`)
       founds.push(NSSDBFileUrl)
     }),
   )
@@ -211,13 +201,13 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
 
   if (verb === VERB_CHECK_TRUST) {
     if (missingCount > 0 || outdatedCount > 0) {
-      logger.info(`${infoSign} certificate not found in ${browserName}`)
+      logger.info(`${UNICODE.INFO} certificate not found in ${browserName}`)
       return {
         status: "not_trusted",
         reason: `missing or outdated in ${browserName} nss database file`,
       }
     }
-    logger.info(`${okSign} certificate found in ${browserName}`)
+    logger.info(`${UNICODE.OK} certificate found in ${browserName}`)
     return {
       status: "trusted",
       reason: `found in ${browserName} nss database file`,
@@ -226,13 +216,13 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
 
   if (verb === VERB_ADD_TRUST) {
     if (missingCount === 0 && outdatedCount === 0) {
-      logger.info(`${okSign} certificate found in ${browserName}`)
+      logger.info(`${UNICODE.OK} certificate found in ${browserName}`)
       return {
         status: "trusted",
         reason: `found in all ${browserName} nss database file`,
       }
     }
-    logger.info(`${infoSign} certificate not found in ${browserName}`)
+    logger.info(`${UNICODE.INFO} certificate not found in ${browserName}`)
     logger.info(`Adding certificate to ${browserName}...`)
     await getBrowserClosedPromise()
     await Promise.all(
@@ -246,7 +236,7 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
         await addToNSSDB({ NSSDBFileUrl: outdated })
       }),
     )
-    logger.info(`${okSign} certificate added to ${browserName}`)
+    logger.info(`${UNICODE.OK} certificate added to ${browserName}`)
     return {
       status: "trusted",
       reason: `added to ${browserName} nss database file`,
@@ -254,13 +244,13 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
   }
 
   if (outdatedCount === 0 && foundCount === 0) {
-    logger.info(`${infoSign} certificate not found in ${browserName}`)
+    logger.info(`${UNICODE.INFO} certificate not found in ${browserName}`)
     return {
       status: "not_trusted",
       reason: `not found in ${browserName} nss database file`,
     }
   }
-  logger.info(`${infoSign} found certificate in ${browserName}`)
+  logger.info(`${UNICODE.INFO} found certificate in ${browserName}`)
   logger.info(`Removing certificate from ${browserName}...`)
   await getBrowserClosedPromise()
   await Promise.all(
@@ -273,7 +263,7 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
       await removeFromNSSDB({ NSSDBFileUrl: found })
     }),
   )
-  logger.info(`${okSign} certificate removed from ${browserName}`)
+  logger.info(`${UNICODE.OK} certificate removed from ${browserName}`)
   return {
     status: "not_trusted",
     reason: `removed from ${browserName} nss database file`,
@@ -302,7 +292,7 @@ const findNSSDBFiles = async ({ logger, NSSDBDirectoryUrl }) => {
   const NSSDBDirectoryExists = existsSync(NSSDBDirectoryPath)
   if (!NSSDBDirectoryExists) {
     logger.info(
-      `${infoSign} nss database directory not found on filesystem at ${NSSDBDirectoryPath}`,
+      `${UNICODE.INFO} nss database directory not found on filesystem at ${NSSDBDirectoryPath}`,
     )
     NSSDirectoryCache[NSSDBDirectoryUrl] = []
     return []
@@ -324,14 +314,14 @@ const findNSSDBFiles = async ({ logger, NSSDBDirectoryUrl }) => {
   const fileCount = NSSDBFiles.length
   if (fileCount === 0) {
     logger.warn(
-      `${warningSign} could not find nss database file in ${NSSDBDirectoryUrl}`,
+      `${UNICODE.WARNING} could not find nss database file in ${NSSDBDirectoryUrl}`,
     )
     NSSDirectoryCache[NSSDBDirectoryUrl] = []
     return []
   }
 
   logger.debug(
-    `${okSign} found ${fileCount} nss database file in ${NSSDBDirectoryUrl}`,
+    `${UNICODE.OK} found ${fileCount} nss database file in ${NSSDBDirectoryUrl}`,
   )
   const files = NSSDBFiles.map((file) => {
     return resolveUrl(file.relativeUrl, NSSDBDirectoryUrl)

package/src/internal/unsupported_platform/unsupported_platform.js

@@ -1,4 +1,4 @@
-import { warningSign } from "@jsenv/https-local/src/internal/logs.js"
+import { UNICODE } from "@jsenv/log"
 
 const platformTrustInfo = {
   status: "unknown",
@@ -7,7 +7,7 @@ const platformTrustInfo = {
 
 export const executeTrustQuery = ({ logger }) => {
   logger.warn(
-    `${warningSign} platform not supported, cannot execute trust query`,
+    `${UNICODE.WARNING} platform not supported, cannot execute trust query`,
   )
   return {
     platform: platformTrustInfo,

package/src/internal/windows/chrome_windows.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module"
 import { existsSync } from "node:fs"
+import { UNICODE } from "@jsenv/log"
 
-import { okSign, infoSign } from "@jsenv/https-local/src/internal/logs.js"
 import { memoize } from "@jsenv/https-local/src/internal/memoize.js"
 
 const require = createRequire(import.meta.url)
@@ -30,7 +30,7 @@ const detectChrome = memoize(({ logger }) => {
   logger.debug(`Detecting Chrome...`)
 
   if (process.env.CHROME_BIN && which.sync(process.env.CHROME_BIN)) {
-    logger.debug(`${okSign} Chrome detected`)
+    logger.debug(`${UNICODE.OK} Chrome detected`)
     return true
   }
 
@@ -53,10 +53,10 @@ const detectChrome = memoize(({ logger }) => {
     },
   )
   if (someExecutableFound) {
-    logger.debug(`${okSign} Chrome detected`)
+    logger.debug(`${UNICODE.OK} Chrome detected`)
     return true
   }
 
-  logger.debug(`${infoSign} Chrome detected`)
+  logger.debug(`${UNICODE.OK} Chrome detected`)
   return false
 })

package/src/internal/windows/firefox_windows.js

@@ -5,8 +5,8 @@
 
 import { createRequire } from "node:module"
 import { existsSync } from "node:fs"
+import { UNICODE } from "@jsenv/log"
 
-import { okSign, infoSign } from "@jsenv/https-local/src/internal/logs.js"
 import { memoize } from "@jsenv/https-local/src/internal/memoize.js"
 
 const require = createRequire(import.meta.url)
@@ -26,7 +26,7 @@ export const executeTrustQueryOnFirefox = ({ logger, certificateIsNew }) => {
   }
 
   if (certificateIsNew) {
-    logger.info(`${infoSign} 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",
@@ -35,7 +35,7 @@ export const executeTrustQueryOnFirefox = ({ logger, certificateIsNew }) => {
 
   logger.info(`Check if certificate is in firefox...`)
   logger.info(
-    `${infoSign} cannot check if certificate is in firefox (${REASON_NOT_IMPLEMENTED_ON_WINDOWS})`,
+    `${UNICODE.INFO} cannot check if certificate is in firefox (${REASON_NOT_IMPLEMENTED_ON_WINDOWS})`,
   )
   return {
     status: "unknown",
@@ -48,7 +48,7 @@ const detectFirefox = memoize(({ logger }) => {
   logger.debug(`Detecting Firefox...`)
 
   if (process.env.FIREFOX_BIN && which.sync(process.env.FIREFOX_BIN)) {
-    logger.debug(`${okSign} Firefox detected`)
+    logger.debug(`${UNICODE.OK} Firefox detected`)
     return true
   }
 
@@ -71,10 +71,10 @@ const detectFirefox = memoize(({ logger }) => {
     },
   )
   if (someExecutableFound) {
-    logger.debug(`${okSign} Firefox detected`)
+    logger.debug(`${UNICODE.OK} Firefox detected`)
     return true
   }
 
-  logger.debug(`${infoSign} Firefox detected`)
+  logger.debug(`${UNICODE.INFO} Firefox detected`)
   return false
 })

package/src/internal/windows/windows_certutil.js

@@ -5,13 +5,8 @@
 
 import { createDetailedMessage } from "@jsenv/logger"
 import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { UNICODE } from "@jsenv/log"
 
-import {
-  commandSign,
-  okSign,
-  infoSign,
-  failureSign,
-} from "@jsenv/https-local/src/internal/logs.js"
 import { exec } from "@jsenv/https-local/src/internal/exec.js"
 import {
   VERB_CHECK_TRUST,
@@ -41,7 +36,7 @@ export const executeTrustQueryOnWindows = async ({
   verb,
 }) => {
   if (verb === VERB_CHECK_TRUST && certificateIsNew) {
-    logger.info(`${infoSign} 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,
@@ -52,7 +47,7 @@ export const executeTrustQueryOnWindows = async ({
   // 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(`${commandSign} ${certutilListCommand}`)
+  logger.debug(`${UNICODE.COMMAND} ${certutilListCommand}`)
   const certutilListCommandOutput = await exec(certutilListCommand)
   const certificateFilePath = urlToFileSystemPath(certificateFileUrl)
 
@@ -62,7 +57,7 @@ export const executeTrustQueryOnWindows = async ({
     certificateCommonName,
   )
   if (!certificateInStore) {
-    logger.info(`${infoSign} 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",
@@ -73,10 +68,10 @@ export const executeTrustQueryOnWindows = async ({
     // 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(`${commandSign} ${certutilAddCommand}`)
+    logger.info(`${UNICODE.COMMAND} ${certutilAddCommand}`)
     try {
       await exec(certutilAddCommand)
-      logger.info(`${okSign} certificate added to windows`)
+      logger.info(`${UNICODE.OK} certificate added to windows`)
       return {
         status: "trusted",
         reason: REASON_ADD_COMMAND_COMPLETED,
@@ -84,7 +79,7 @@ export const executeTrustQueryOnWindows = async ({
     } catch (e) {
       logger.error(
         createDetailedMessage(
-          `${failureSign} Failed to add certificate to windows`,
+          `${UNICODE.FAILURE} Failed to add certificate to windows`,
           {
             "error stack": e.stack,
             "certificate file": certificateFilePath,
@@ -98,7 +93,7 @@ export const executeTrustQueryOnWindows = async ({
     }
   }
 
-  logger.info(`${okSign} certificate found in windows`)
+  logger.info(`${UNICODE.OK} certificate found in windows`)
   if (verb === VERB_CHECK_TRUST || verb === VERB_ADD_TRUST) {
     return {
       status: "trusted",
@@ -109,10 +104,10 @@ export const executeTrustQueryOnWindows = async ({
   // 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(`${commandSign} ${certutilRemoveCommand}`)
+  logger.info(`${UNICODE.COMMAND} ${certutilRemoveCommand}`)
   try {
     await exec(certutilRemoveCommand)
-    logger.info(`${okSign} certificate removed from windows`)
+    logger.info(`${UNICODE.OK} certificate removed from windows`)
     return {
       status: "not_trusted",
       reason: REASON_DELETE_COMMAND_COMPLETED,
@@ -120,7 +115,7 @@ export const executeTrustQueryOnWindows = async ({
   } catch (e) {
     logger.error(
       createDetailedMessage(
-        `${failureSign} failed to remove certificate from windows`,
+        `${UNICODE.FAILURE} failed to remove certificate from windows`,
         {
           "error stack": e.stack,
           "certificate file": certificateFilePath,

package/src/internal/logs.js

@@ -1,23 +0,0 @@
-import isUnicodeSupported from "is-unicode-supported"
-import { createSupportsColor } from "supports-color"
-
-const canUseUnicode = isUnicodeSupported()
-const processSupportsBasicColor = createSupportsColor(process.stdout).hasBasic
-
-export const ANSI_RED = "\x1b[31m"
-export const ANSI_GREEN = "\x1b[32m"
-export const ANSI_YELLOW = "\x1b[33m"
-export const ANSI_BLUE = "\x1b[34m"
-export const ANSI_MAGENTA = "\x1b[35m"
-export const ANSI_GREY = "\x1b[39m"
-export const ANSI_RESET = "\x1b[0m"
-
-export const setANSIColor = processSupportsBasicColor
-  ? (text, ANSI_COLOR) => `${ANSI_COLOR}${text}${ANSI_RESET}`
-  : (text) => text
-
-export const commandSign = setANSIColor(canUseUnicode ? `❯` : `>`, ANSI_GREY) // ANSI_MAGENTA)
-export const okSign = setANSIColor(canUseUnicode ? `✔` : `√`, ANSI_GREEN)
-export const failureSign = setANSIColor(canUseUnicode ? `✖` : `×`, ANSI_RED)
-export const infoSign = setANSIColor(canUseUnicode ? `ℹ` : `i`, ANSI_BLUE)
-export const warningSign = setANSIColor(canUseUnicode ? `⚠` : `‼`, ANSI_YELLOW)