@dotenvx/dotenvx 1.75.1 → 2.1.0

package/src/cli/actions/keypair.js

@@ -1,12 +1,12 @@
 const { logger } = require('./../../shared/logger')
 
-const Keypair = require('./../../lib/services/keypair')
+const keypairResolver = require('./../../lib/resolvers/keypair')
+const catchAndLog = require('./../../lib/helpers/catchAndLog')
 const createSpinner = require('../../lib/helpers/createSpinner')
-const Session = require('../../db/session')
-const normalizeArmorOptions = require('./normalizeArmorOptions')
+const normalizeArmorAliases = require('./normalizeArmorAliases')
 
 async function keypair (key) {
-  const options = normalizeArmorOptions(this.opts())
+  const options = normalizeArmorAliases(this.opts())
   const spinner = await createSpinner({ ...options, text: 'retrieving' })
 
   logger.debug(`options: ${JSON.stringify(options)}`)
@@ -16,50 +16,63 @@ async function keypair (key) {
 
   const prettyPrint = options.prettyPrint || options.pp
 
-  const sesh = new Session()
-  const noArmor = options.armor === false || await sesh.noArmor()
-  if (spinner) spinner.stop()
-  const keypairs = await new Keypair(options.envFile, options.envKeysFile, noArmor, {
-    command: process.argv.slice(2)
-  }).run()
-  const results = key ? keypairs[key] : keypairs
-
-  if (spinner) spinner.stop()
-  if (typeof results === 'object' && results !== null) {
-    if (options.format === 'shell') {
-      let inline = ''
-      for (const [keyName, value] of Object.entries(results)) {
-        inline += `${keyName}=${value || ''} `
+  try {
+    const keypairs = await keypairResolver({
+      envFile: options.envFile,
+      envKeysFile: options.envKeysFile,
+      armor: options.armor,
+      token: options.token,
+      command: process.argv.slice(2),
+      onStatus: (text) => {
+        if (spinner && text) {
+          spinner.text = text
+        }
       }
-      inline = inline.trim()
+    })
 
-      console.log(inline)
-    } else if (options.format === 'colon') {
-      let inline = ''
-      for (const [keyName, value] of Object.entries(results)) {
-        inline += `${keyName}:${value || ''} `
-      }
-      inline = inline.trim()
+    const results = key ? keypairs[key] : keypairs
 
-      console.log(inline)
-    // json format
-    } else {
-      let space = 0
-      if (prettyPrint) {
-        space = 2
-      }
+    if (spinner) spinner.stop()
+    if (typeof results === 'object' && results !== null) {
+      if (options.format === 'shell') {
+        let inline = ''
+        for (const [keyName, value] of Object.entries(results)) {
+          inline += `${keyName}=${value || ''} `
+        }
+        inline = inline.trim()
 
-      console.log(JSON.stringify(results, null, space))
-    }
-  } else {
-    if (results === undefined) {
-      console.log('')
-      process.exit(1)
-    } else if (options.format === 'colon' && key) {
-      console.log(`${key}:${results}`)
+        console.log(inline)
+      } else if (options.format === 'colon') {
+        let inline = ''
+        for (const [keyName, value] of Object.entries(results)) {
+          inline += `${keyName}:${value || ''} `
+        }
+        inline = inline.trim()
+
+        console.log(inline)
+      // json format
+      } else {
+        let space = 0
+        if (prettyPrint) {
+          space = 2
+        }
+
+        console.log(JSON.stringify(results, null, space))
+      }
     } else {
-      console.log(results)
+      if (results === undefined) {
+        console.log('')
+        process.exit(1)
+      } else if (options.format === 'colon' && key) {
+        console.log(`${key}:${results}`)
+      } else {
+        console.log(results)
+      }
     }
+  } catch (error) {
+    if (spinner) spinner.stop()
+    catchAndLog(error)
+    process.exit(1)
   }
 }
 

package/src/cli/actions/login.js

@@ -2,7 +2,6 @@ const { logger } = require('../../shared/logger')
 
 const Session = require('../../db/session')
 const Login = require('../../lib/services/login')
-const LoginPoll = require('../../lib/services/loginPoll')
 
 const createSpinner = require('../../lib/helpers/createSpinner')
 const formatCode = require('../../lib/helpers/formatCode')
@@ -20,15 +19,17 @@ async function login () {
   const sesh = new Session()
   const hostname = options.hostname || sesh.hostname()
   let cleanupOpenKeyListener = () => {}
+  let loginService
 
   try {
+    loginService = new Login(hostname)
     const {
       deviceCode,
       userCode,
       verificationUri,
       verificationUriComplete,
       interval
-    } = await new Login(hostname).run()
+    } = await loginService.run()
 
     const promptMessage = `◌ press Enter to open [${verificationUri}] and enter code [${formatCode(userCode)}]...`
 
@@ -36,7 +37,7 @@ async function login () {
     logger.info(promptMessage)
 
     // begin polling
-    const pollPromise = new LoginPoll(hostname, deviceCode, interval).run()
+    const pollPromise = loginService.poll(deviceCode, interval)
     cleanupOpenKeyListener = listenForOpenKey(() => openUrl(verificationUriComplete))
     const data = await pollPromise
 

package/src/cli/actions/normalizeArmorAliases.js

@@ -0,0 +1,9 @@
+function normalizeArmorAliases (options) {
+  if (options.ops === false) {
+    options.armor = false
+  }
+
+  return options
+}
+
+module.exports = normalizeArmorAliases

package/src/cli/actions/run.js

@@ -2,18 +2,56 @@ const path = require('path')
 const { logger } = require('./../../shared/logger')
 
 const executeCommand = require('./../../lib/helpers/executeCommand')
-const Run = require('./../../lib/services/run')
+const envsResolver = require('./../../lib/resolvers/envs')
 const catchAndLog = require('./../../lib/helpers/catchAndLog')
 const createSpinner = require('../../lib/helpers/createSpinner')
 const Session = require('../../db/session')
-const normalizeArmorOptions = require('./normalizeArmorOptions')
+const normalizeArmorAliases = require('./normalizeArmorAliases')
 
 const conventions = require('./../../lib/helpers/conventions')
 const { determine } = require('./../../lib/helpers/envResolution')
 
+function inferCommandArgsFromProcessArgv (argv) {
+  const runIndex = argv.indexOf('run')
+  if (runIndex === -1) return []
+
+  const args = argv.slice(runIndex + 1)
+
+  const separatorIndex = args.indexOf('--')
+  if (separatorIndex !== -1) return args.slice(separatorIndex + 1)
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '-f' || args[i] === '--env-file') {
+      i++
+      continue
+    }
+
+    if (args[i].startsWith('-')) continue
+
+    return args.slice(i)
+  }
+
+  return []
+}
+
+function uniqueInjectedKeys (processedEnvs) {
+  const result = new Set()
+  for (const processedEnv of processedEnvs) {
+    for (const key of Object.keys(processedEnv.injected || {})) {
+      result.add(key)
+    }
+  }
+  return result
+}
+
 async function run () {
-  const options = normalizeArmorOptions(this.opts())
-  const commandArgs = this.args
+  const options = normalizeArmorAliases(this.opts())
+
+  let commandArgs = this.args
+  if (commandArgs.length < 1) {
+    commandArgs = inferCommandArgsFromProcessArgv(process.argv)
+  }
+
   const spinner = await createSpinner({ ...options, text: 'injecting' })
 
   logger.debug(`options: ${JSON.stringify(options)}`)
@@ -48,17 +86,24 @@ async function run () {
       envs = this.envs
     }
     envs = determine(envs, process.env)
-    if (spinner) spinner.stop()
 
     const {
       processedEnvs,
-      readableStrings,
-      readableFilepaths,
-      uniqueInjectedKeys
-    } = await new Run(envs, options.overload, process.env, options.envKeysFile, noArmor, {
+      readableFilepaths
+    } = await envsResolver({
+      envs,
+      overload: options.overload,
+      processEnv: process.env,
+      envKeysFile: options.envKeysFile,
+      noArmor,
       token: options.token,
-      command: commandArgs
-    }).run()
+      command: commandArgs,
+      onStatus: (text) => {
+        if (spinner && text) {
+          spinner.text = text
+        }
+      }
+    })
 
     for (const processedEnv of processedEnvs) {
       if (processedEnv.type === 'envFile') {
@@ -93,27 +138,25 @@ async function run () {
         logger.debug(`${key} set to ${value}`)
       }
 
-      // verbose/debug preExisted key/value
-      for (const [key, value] of Object.entries(processedEnv.preExisted || {})) {
+      // verbose/debug existed key/value
+      for (const [key, value] of Object.entries(processedEnv.existed || {})) {
         logger.verbose(`${key} pre-exists (protip: use --overload to override)`)
         logger.debug(`${key} pre-exists as ${value} (protip: use --overload to override)`)
       }
     }
 
-    let msg = `injected env (${uniqueInjectedKeys.length})`
-    if (readableFilepaths.length > 0 && readableStrings.length > 0) {
-      msg += ` from ${readableFilepaths.join(', ')}, and --env flag${readableStrings.length > 1 ? 's' : ''}`
+    let msg = `injected env (${uniqueInjectedKeys(processedEnvs).size})`
+    const envStringCount = processedEnvs.filter((processedEnv) => processedEnv.type === 'env' && processedEnv.parsed).length
+    if (readableFilepaths.length > 0 && envStringCount > 0) {
+      msg += ` from ${readableFilepaths.join(', ')}, and --env flag${envStringCount > 1 ? 's' : ''}`
     } else if (readableFilepaths.length > 0) {
       msg += ` from ${readableFilepaths.join(', ')}`
-    } else if (readableStrings.length > 0) {
-      msg += ` from --env flag${readableStrings.length > 1 ? 's' : ''}`
+    } else if (envStringCount > 0) {
+      msg += ` from --env flag${envStringCount > 1 ? 's' : ''}`
     }
 
-    const armoredPrivateKeyUsed = processedEnvs.some((processedEnv) => processedEnv.armoredPrivateKeyUsed)
-    const keyUsedSuffix = armoredPrivateKeyUsed ? ' · armored ⛨' : ''
-
     if (spinner) spinner.stop()
-    logger.success(`⟐ ${msg}${keyUsedSuffix}`)
+    logger.success(`⟐ ${msg}`)
   } catch (error) {
     if (spinner) spinner.stop()
     catchAndLog(error)

package/src/cli/actions/set.js

@@ -1,87 +1,137 @@
 const fsx = require('./../../lib/helpers/fsx')
 const { logger } = require('./../../shared/logger')
 
+const setTransform = require('./../../lib/transforms/set')
+
 const catchAndLog = require('../../lib/helpers/catchAndLog')
 const createSpinner = require('../../lib/helpers/createSpinner')
+const Errors = require('../../lib/helpers/errors')
+const prompts = require('../../lib/helpers/prompts')
 const Session = require('../../db/session')
-const Sets = require('./../../lib/services/sets')
-const normalizeArmorOptions = require('./normalizeArmorOptions')
+const normalizeArmorAliases = require('./normalizeArmorAliases')
 
 async function set (key, value) {
-  const options = normalizeArmorOptions(this.opts())
+  const options = normalizeArmorAliases(this.opts())
 
   let encrypt = true
   let settingMessage = 'encrypting'
+  let settingSymbol = '◈'
   if (options.plain) {
     encrypt = false
     settingMessage = 'setting'
+    settingSymbol = '◇'
+  }
+
+  if (typeof value === 'undefined') {
+    if (!process.stdin.isTTY) {
+      catchAndLog(new Errors({ key }).missingValue())
+      process.exit(1)
+      return
+    }
+
+    try {
+      value = await prompts.password({
+        message: key,
+        prefix: settingSymbol,
+        separator: '='
+      }, {
+        input: process.stdin,
+        output: process.stderr
+      })
+    } catch (error) {
+      if (error.code === 'PROMPT_CANCELLED') {
+        process.exit(130)
+        return
+      }
+
+      throw error
+    }
+  }
+
+  if (value === '') {
+    catchAndLog(new Errors({ key }).missingValue())
+    process.exit(1)
+    return
   }
 
   const spinner = await createSpinner({ ...options, text: settingMessage })
+  const sesh = new Session()
 
   logger.debug(`key: ${key}`)
   logger.debug(`value: ${value}`)
   logger.debug(`options: ${JSON.stringify(options)}`)
 
+  const envs = this.envs || []
+  const fk = options.envKeysFile || '.env.keys'
+  const noCreate = options.create === false
+  const noArmor = options.armor === false || (!options.token && (await sesh.noArmor()))
+
+  let errorCount = 0
+
   try {
-    const envs = this.envs
-    const envKeysFilepath = options.envKeysFile
-    const sesh = new Session()
-    const noArmor = options.armor === false || (await sesh.noArmor())
-    const noCreate = options.create === false
+    const { keysSrc, processedEnvs, changedFilepaths, unchangedFilepaths } = await setTransform({ envs, key, value, fk, noArmor, noCreate, encrypt })
 
-    if (spinner) spinner.stop()
-    const {
-      processedEnvs,
-      changedFilepaths,
-      unchangedFilepaths
-    } = await new Sets(key, value, envs, encrypt, envKeysFilepath, noArmor, noCreate, {
-      command: process.argv.slice(2)
-    }).run()
+    if (keysSrc) {
+      await fsx.writeFileX(fk, keysSrc)
+    }
 
     let withEncryption = ''
-
     if (encrypt) {
       withEncryption = ' with encryption'
     }
 
+    if (spinner) spinner.stop()
     for (const processedEnv of processedEnvs) {
       logger.verbose(`setting for ${processedEnv.envFilepath}`)
-
       if (processedEnv.error) {
-        logger.warn(processedEnv.error.messageWithHelp)
-      } else {
+        errorCount += 1
+        logger.error(processedEnv.error.messageWithHelp || processedEnv.error.message)
+      } else if (processedEnv.changed) {
         await fsx.writeFileX(processedEnv.filepath, processedEnv.envSrc)
-
         logger.verbose(`${processedEnv.key} set${withEncryption} (${processedEnv.envFilepath})`)
-        logger.debug(`${processedEnv.key} set${withEncryption} to ${processedEnv.value} (${processedEnv.envFilepath})`)
+      } else {
+        logger.verbose(`no change ${processedEnv.envFilepath} (${processedEnv.filepath})`)
       }
     }
 
-    const localKeyAddedEnv = processedEnvs.find((processedEnv) => processedEnv.localPrivateKeyAdded)
-    const remoteKeyAddedEnv = processedEnvs.find((processedEnv) => processedEnv.remotePrivateKeyAdded)
-    let keyAddedSuffix = ''
-    if (remoteKeyAddedEnv) {
-      keyAddedSuffix = ' · armored ⛨'
-    }
+    // const localKeyAddedEnv = processedEnvs.find((processedEnv) => processedEnv.localPrivateKeyAdded)
+    // const remoteKeyAddedEnv = processedEnvs.find((processedEnv) => processedEnv.remotePrivateKeyAdded)
+    // let keyAddedSuffix = ''
+    // if (remoteKeyAddedEnv) {
+    //   keyAddedSuffix = ' · armored ⛨'
+    // }
 
-    if (spinner) spinner.stop()
     if (changedFilepaths.length > 0) {
+      let msg = `◇ set ${key} (${changedFilepaths.join(',')})`
       if (encrypt) {
-        logger.success(`◈ encrypted ${key} (${changedFilepaths.join(',')})${keyAddedSuffix}`)
-      } else {
-        logger.success(`◇ set ${key} (${changedFilepaths.join(',')})`)
+        msg = `◈ encrypted ${key} (${changedFilepaths.join(',')})`
       }
-    } else if (encrypt && localKeyAddedEnv) {
-      const localKeyAddedEnvFilepath = localKeyAddedEnv.envFilepath || changedFilepaths[0] || '.env'
-      logger.success(`◈ encrypted ${key} (${localKeyAddedEnvFilepath})${keyAddedSuffix}`)
+
+      logger.success(msg)
+
+      // if (encrypt) {
+      //   logger.success(`◈ encrypted ${key} (${changedFilepaths.join(',')})${keyAddedSuffix}`)
+      // } else {
+      //   logger.success(`◇ set ${key} (${changedFilepaths.join(',')})`)
+      // }
     } else if (unchangedFilepaths.length > 0) {
       logger.info(`○ no change (${unchangedFilepaths})`)
     } else {
-      // do nothing
+      // do nothing - scenario when no .env files found
     }
 
-    // intentionally quiet: success line communicates key creation
+    // } else if (encrypt && localKeyAddedEnv) {
+    //   const localKeyAddedEnvFilepath = localKeyAddedEnv.envFilepath || changedFilepaths[0] || '.env'
+    //   logger.success(`◈ encrypted ${key} (${localKeyAddedEnvFilepath})${keyAddedSuffix}`)
+    // } else if (unchangedFilepaths.length > 0) {
+    //   logger.info(`○ no change (${unchangedFilepaths})`)
+    // } else {
+    //   // do nothing
+    // }
+
+    if (errorCount > 0) {
+      process.exit(1)
+    }
   } catch (error) {
     if (spinner) spinner.stop()
     catchAndLog(error)

package/src/cli/dotenvx.js

@@ -64,7 +64,7 @@ program.command('run')
   .description('inject env at runtime [dotenvx run -- yourcommand]')
   .addHelpText('after', examples.run)
   .option('-e, --env <strings...>', 'environment variable(s) set as string (example: "HELLO=World")', collectEnvs('env'), [])
-  .option('-f, --env-file <paths...>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
+  .option('-f, --env-file <path>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
   .option('-fk, --env-keys-file <path>', 'path to your .env.keys file (default: same path as your env file)')
   .option('-o, --overload', 'override existing env variables (by default, existing env vars take precedence over .env files)')
   .option('--strict', 'process.exit(1) on any errors', false)
@@ -84,7 +84,7 @@ program.command('get')
   .description('return a single environment variable')
   .argument('[KEY]', 'environment variable name')
   .option('-e, --env <strings...>', 'environment variable(s) set as string (example: "HELLO=World")', collectEnvs('env'), [])
-  .option('-f, --env-file <paths...>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
+  .option('-f, --env-file <path>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
   .option('-fk, --env-keys-file <path>', 'path to your .env.keys file (default: same path as your env file)')
   .option('-o, --overload', 'override existing env variables (by default, existing env vars take precedence over .env files)')
   .option('--strict', 'process.exit(1) on any errors', false)
@@ -103,13 +103,13 @@ program.command('get')
 
 // dotenvx set
 program.command('set')
-  .usage('<KEY> <value> [options]')
+  .usage('<KEY> [value] [options]')
   .description('encrypt a single environment variable')
   .addHelpText('after', examples.set)
   .allowUnknownOption()
   .argument('KEY', 'KEY')
-  .argument('value', 'value')
-  .option('-f, --env-file <paths...>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
+  .argument('[value]', 'value')
+  .option('-f, --env-file <path>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
   .option('-fk, --env-keys-file <path>', 'path to your .env.keys file (default: same path as your env file)')
   .option('-c, --encrypt', 'encrypt value', true)
   .option('-p, --plain', 'store value as plain text', false)
@@ -124,7 +124,7 @@ program.command('set')
 // dotenvx encrypt
 program.command('encrypt')
   .description('encrypt .env file(s)')
-  .option('-f, --env-file <paths...>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
+  .option('-f, --env-file <path>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
   .option('-fk, --env-keys-file <path>', 'path to your .env.keys file (default: same path as your env file)')
   .option('-k, --key <keys...>', 'keys(s) to encrypt (default: all keys in file)')
   .option('-ek, --exclude-key <excludeKeys...>', 'keys(s) to exclude from encryption (default: none)')
@@ -141,7 +141,7 @@ program.command('encrypt')
 // dotenvx decrypt
 program.command('decrypt')
   .description('decrypt .env file(s)')
-  .option('-f, --env-file <paths...>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
+  .option('-f, --env-file <path>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
   .option('-fk, --env-keys-file <path>', 'path to your .env.keys file (default: same path as your env file)')
   .option('-k, --key <keys...>', 'keys(s) to decrypt (default: all keys in file)')
   .option('-ek, --exclude-key <excludeKeys...>', 'keys(s) to exclude from decryption (default: none)')
@@ -153,27 +153,12 @@ program.command('decrypt')
     return require('./actions/decrypt').apply(this, args)
   })
 
-// dotenvx rotate
-program.command('rotate')
-  .description('rotate keypair(s) and re-encrypt .env file(s)')
-  .option('-f, --env-file <paths...>', 'path(s) to your env file(s)', collectEnvs('envFile'), [])
-  .option('-fk, --env-keys-file <path>', 'path to your .env.keys file (default: same path as your env file)')
-  .option('-k, --key <keys...>', 'keys(s) to encrypt (default: all keys in file)')
-  .option('-ek, --exclude-key <excludeKeys...>', 'keys(s) to exclude from encryption (default: none)')
-  .option('--no-armor', 'disable dotenvx-armor features')
-  .addOption(new Option('--no-ops', 'disable dotenvx-ops features (deprecated. use --no-armor)').hideHelp())
-  .option('--stdout', 'send to stdout')
-  .action(function (...args) {
-    this.envs = envs
-    return require('./actions/rotate').apply(this, args)
-  })
-
 // dotenvx keypair
 program.command('keypair')
   .usage('[KEY] [options]')
   .description('print public/private keys for .env file(s)')
   .argument('[KEY]', 'environment variable key name')
-  .option('-f, --env-file <paths...>', 'path(s) to your env file(s)')
+  .option('-f, --env-file <path>', 'path(s) to your env file(s)')
   .option('-fk, --env-keys-file <path>', 'path to your .env.keys file (default: same path as your env file)')
   .option('--no-armor', 'disable dotenvx-armor features')
   .addOption(new Option('--no-ops', 'disable dotenvx-ops features (deprecated. use --no-armor)').hideHelp())

package/src/lib/api/{postKeypair.js → postArmorKeyring.js}

@@ -3,20 +3,18 @@ const buildApiError = require('../helpers/buildApiError')
 const packageJson = require('../helpers/packageJson')
 const normalizeToken = require('../helpers/normalizeToken')
 
-class PostKeypair {
-  constructor (hostname, token, devicePublicKey, publicKey, team, metadata, grantToken) {
+class PostArmorKeyring {
+  constructor (hostname, token, devicePublicKey, publicKey, grantToken) {
     this.hostname = hostname || 'https://armor.dotenvx.com'
     this.token = token
     this.devicePublicKey = devicePublicKey
     this.publicKey = publicKey
-    this.team = team
-    this.metadata = metadata
     this.grantToken = grantToken
   }
 
   async run () {
     const token = normalizeToken(this.token)
-    const url = `${this.hostname}/api/keypair`
+    const url = `${this.hostname}/api/armor/keyring`
     const body = {
       device_public_key: this.devicePublicKey,
       cli_version: packageJson.version
@@ -26,14 +24,6 @@ class PostKeypair {
       body.public_key = this.publicKey
     }
 
-    if (this.team) {
-      body.team = this.team
-    }
-
-    if (this.metadata && Object.keys(this.metadata).length > 0) {
-      body.metadata = this.metadata
-    }
-
     if (this.grantToken) {
       body.grant_token = this.grantToken
     }
@@ -57,4 +47,4 @@ class PostKeypair {
   }
 }
 
-module.exports = PostKeypair
+module.exports = PostArmorKeyring

package/src/lib/{helpers/envResolution → conventions}/environment.js

@@ -1,4 +1,4 @@
-const canonicalEnvFilename = require('./../canonicalEnvFilename')
+const canonicalEnvFilename = require('../helpers/canonicalEnvFilename')
 
 function environment (filepath) {
   const filename = canonicalEnvFilename(filepath)

package/src/lib/conventions/filepaths.js

@@ -0,0 +1,9 @@
+function filepaths (envFile = '.env') {
+  if (!Array.isArray(envFile)) {
+    return [envFile]
+  }
+
+  return envFile
+}
+
+module.exports = filepaths

package/src/lib/conventions/keynames.js

@@ -0,0 +1,38 @@
+const { scan } = require('@dotenvx/primitives')
+const canonicalEnvFilename = require('../helpers/canonicalEnvFilename')
+const environment = require('./environment')
+
+function keynames (filepath = '.env', src = '') {
+  const { parsed } = scan(src)
+
+  // src public key name wins
+  for (const publicKeyName in parsed) {
+    if (publicKeyName.startsWith('DOTENV_PUBLIC_KEY')) {
+      return {
+        publicKeyName,
+        privateKeyName: publicKeyName.replace('DOTENV_PUBLIC_KEY', 'DOTENV_PRIVATE_KEY')
+      }
+    }
+  }
+
+  const filename = canonicalEnvFilename(filepath)
+
+  // .env
+  if (filename === '.env') {
+    return {
+      publicKeyName: 'DOTENV_PUBLIC_KEY',
+      privateKeyName: 'DOTENV_PRIVATE_KEY'
+    }
+  }
+
+  // .env.ENVIRONMENT
+  const resolvedEnvironment = environment(filename).toUpperCase()
+
+  return {
+    publicKeyName: `DOTENV_PUBLIC_KEY_${resolvedEnvironment}`,
+    privateKeyName: `DOTENV_PRIVATE_KEY_${resolvedEnvironment}`
+  }
+}
+
+module.exports = keynames
+module.exports.keynames = keynames

package/src/lib/helpers/catchAndLog.js

@@ -1,7 +1,10 @@
 const { logger } = require('./../../shared/logger')
 
 function catchAndLog (error) {
-  logger.error(error.messageWithHelp || error.message)
+  const msg = error.messageWithHelp || error.message
+  if (msg) {
+    logger.error(msg)
+  }
   if (error.debug) {
     logger.debug(error.debug)
   }