@dotenvx/dotenvx 1.69.2 → 1.71.0

package/src/lib/helpers/cryptography/{vltKeypair.js → armorKeypair.js}

@@ -1,6 +1,6 @@
-const Vlt = require('../../extensions/vlt')
+const Armor = require('../../extensions/armor')
 
-async function vltKeypair (existingPublicKey, options = {}) {
+async function armorKeypair (existingPublicKey, options = {}) {
   const hooks = options.hooks || {}
   if (hooks.before) await hooks.before()
 
@@ -13,7 +13,7 @@ async function vltKeypair (existingPublicKey, options = {}) {
 
   let kp
   try {
-    kp = await new Vlt().keypair(existingPublicKey, keypairOptions)
+    kp = await new Armor().keypair(existingPublicKey, keypairOptions)
   } finally {
     if (hooks.after) await hooks.after()
   }
@@ -27,4 +27,4 @@ async function vltKeypair (existingPublicKey, options = {}) {
   }
 }
 
-module.exports = vltKeypair
+module.exports = armorKeypair

package/src/lib/helpers/cryptography/armorKeypairSync.js

@@ -0,0 +1,14 @@
+const Armor = require('../../extensions/armor')
+
+function armorKeypairSync (existingPublicKey, options = {}) {
+  const kp = new Armor().keypairSync(existingPublicKey, options)
+  const publicKey = kp.public_key
+  const privateKey = kp.private_key
+
+  return {
+    publicKey,
+    privateKey
+  }
+}
+
+module.exports = armorKeypairSync

package/src/lib/helpers/cryptography/index.js

@@ -1,6 +1,6 @@
 module.exports = {
-  vltKeypair: require('./vltKeypair'),
-  vltKeypairSync: require('./vltKeypairSync'),
+  armorKeypair: require('./armorKeypair'),
+  armorKeypairSync: require('./armorKeypairSync'),
   localKeypair: require('./localKeypair'),
   encryptValue: require('./encryptValue'),
   decryptKeyValue: require('./decryptKeyValue'),

package/src/lib/helpers/cryptography/mutateKeysSrc.js

@@ -25,7 +25,7 @@ async function mutateKeysSrc ({ envFilepath, keysFilepath, privateKeyName, priva
   keysSrc = keysSrc.length > 1 ? keysSrc : `${FIRST_TIME_KEYS_SRC}\n`
   keysSrc = `${keysSrc}\n${appendPrivateKey}`
 
-  await fsx.writeFileX(resolvedKeysFilepath, keysSrc) // TODO: don't write if ops
+  await fsx.writeFileX(resolvedKeysFilepath, keysSrc) // TODO: don't write if armor
 
   const envKeysFilepath = keysFilepath || path.join(path.dirname(envFilepath), path.basename(resolvedKeysFilepath))
 

package/src/lib/helpers/cryptography/mutateKeysSrcSync.js

@@ -25,7 +25,7 @@ function mutateKeysSrcSync ({ envFilepath, keysFilepath, privateKeyName, private
   keysSrc = keysSrc.length > 1 ? keysSrc : `${FIRST_TIME_KEYS_SRC}\n`
   keysSrc = `${keysSrc}\n${appendPrivateKey}`
 
-  fsx.writeFileXSync(resolvedKeysFilepath, keysSrc) // TODO: don't write if ops
+  fsx.writeFileXSync(resolvedKeysFilepath, keysSrc) // TODO: don't write if armor
 
   const envKeysFilepath = keysFilepath || path.join(path.dirname(envFilepath), path.basename(resolvedKeysFilepath))
 

package/src/lib/helpers/cryptography/provision.js

@@ -1,13 +1,13 @@
 const mutateSrc = require('./mutateSrc')
 const mutateKeysSrc = require('./mutateKeysSrc')
-const vltKeypair = require('./vltKeypair')
+const armorKeypair = require('./armorKeypair')
 const localKeypair = require('./localKeypair')
 const { keyNames } = require('../keyResolution')
 
-async function provision ({ envSrc, envFilepath, keysFilepath, noVlt, token, keypairHooks, selectKeyStorage }) {
-  noVlt = noVlt !== false
-  if (!noVlt && selectKeyStorage) {
-    noVlt = await selectKeyStorage() !== 'armored'
+async function provision ({ envSrc, envFilepath, keysFilepath, noArmor, token, keypairHooks, selectKeyStorage }) {
+  noArmor = noArmor !== false
+  if (!noArmor && selectKeyStorage) {
+    noArmor = await selectKeyStorage() !== 'armored'
   }
 
   const { publicKeyName, privateKeyName } = keyNames(envFilepath)
@@ -19,12 +19,12 @@ async function provision ({ envSrc, envFilepath, keysFilepath, noVlt, token, key
   let localPrivateKeyAdded = false
   let remotePrivateKeyAdded = false
 
-  if (noVlt) {
+  if (noArmor) {
     const kp = localKeypair()
     publicKey = kp.publicKey
     privateKey = kp.privateKey
   } else {
-    const kp = await vltKeypair(undefined, { token, envFilepath, hooks: keypairHooks })
+    const kp = await armorKeypair(undefined, { token, envFilepath, hooks: keypairHooks })
     publicKey = kp.publicKey
     privateKey = kp.privateKey
   }
@@ -32,7 +32,7 @@ async function provision ({ envSrc, envFilepath, keysFilepath, noVlt, token, key
   const mutated = mutateSrc({ envSrc, envFilepath, keysFilepath, publicKeyName, publicKeyValue: publicKey })
   envSrc = mutated.envSrc
 
-  if (noVlt) {
+  if (noArmor) {
     const mutated = await mutateKeysSrc({ envFilepath, keysFilepath, privateKeyName, privateKeyValue: privateKey })
     keysSrc = mutated.keysSrc
     envKeysFilepath = mutated.envKeysFilepath

package/src/lib/helpers/cryptography/provisionSync.js

@@ -1,11 +1,11 @@
 const mutateSrc = require('./mutateSrc')
 const mutateKeysSrcSync = require('./mutateKeysSrcSync')
-const vltKeypairSync = require('./vltKeypairSync')
+const armorKeypairSync = require('./armorKeypairSync')
 const localKeypair = require('./localKeypair')
 const { keyNames } = require('../keyResolution')
 
-function provisionSync ({ envSrc, envFilepath, keysFilepath, noVlt }) {
-  noVlt = noVlt !== false
+function provisionSync ({ envSrc, envFilepath, keysFilepath, noArmor }) {
+  noArmor = noArmor !== false
   const { publicKeyName, privateKeyName } = keyNames(envFilepath)
 
   let publicKey
@@ -15,12 +15,12 @@ function provisionSync ({ envSrc, envFilepath, keysFilepath, noVlt }) {
   let localPrivateKeyAdded = false
   let remotePrivateKeyAdded = false
 
-  if (noVlt) {
+  if (noArmor) {
     const kp = localKeypair()
     publicKey = kp.publicKey
     privateKey = kp.privateKey
   } else {
-    const kp = vltKeypairSync(undefined, { envFilepath })
+    const kp = armorKeypairSync(undefined, { envFilepath })
     publicKey = kp.publicKey
     privateKey = kp.privateKey
   }
@@ -28,7 +28,7 @@ function provisionSync ({ envSrc, envFilepath, keysFilepath, noVlt }) {
   const mutated = mutateSrc({ envSrc, envFilepath, keysFilepath, publicKeyName, publicKeyValue: publicKey })
   envSrc = mutated.envSrc
 
-  if (noVlt) {
+  if (noArmor) {
     const mutated = mutateKeysSrcSync({ envFilepath, keysFilepath, privateKeyName, privateKeyValue: privateKey })
     keysSrc = mutated.keysSrc
     envKeysFilepath = mutated.envKeysFilepath

package/src/lib/helpers/cryptography/provisionWithPrivateKey.js

@@ -3,7 +3,7 @@ const mutateSrc = require('./mutateSrc')
 const localKeypair = require('./localKeypair')
 
 function provisionWithPrivateKey ({ envSrc, envFilepath, keysFilepath, privateKeyValue, publicKeyValue, publicKeyName }) {
-  const { publicKey, privateKey } = localKeypair(privateKeyValue) // noVlt doesn't matter here since privateKeyValue was already discovered prior (via vlt and local) and passed as privateKeyValue
+  const { publicKey, privateKey } = localKeypair(privateKeyValue) // noArmor doesn't matter here since privateKeyValue was already discovered prior (via armor and local) and passed as privateKeyValue
 
   // if derivation doesn't match what's in the file (or preset in env)
   if (publicKeyValue && publicKeyValue !== publicKey) {

package/src/lib/helpers/executeDynamic.js

@@ -2,12 +2,19 @@ const path = require('path')
 const childProcess = require('child_process')
 const { logger } = require('../../shared/logger')
 
-function vltBanner () {
+function armorBanner () {
   const lines = [
-    '                       [www.dotenvx.com/vlt]',
+    '                      [www.dotenvx.com/armor]',
     '–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––',
+    '                            __ ____ __ ',
+    '                           |    ||    |',
+    '                           |  __||__  |',
+    '                           |  ‾‾||‾‾  |',
+    '                           |    ||    |',
+    '                            \\   ||   /',
+    '                              \\ __ /',
     '',
-    '                          Dotenvx + VLT ⛨',
+    '                          Dotenvx Armor ⛨',
     '',
     '                           ARMORED KEYS',
     '               Private keys. Off device. Under guard.',
@@ -15,8 +22,8 @@ function vltBanner () {
     '                                -',
     '',
     '                            Install one',
-    '             [curl -sfS https://dotenvx.sh/vlt | sh]',
-    '                 [npm i @dotenvx/dotenvx --save]',
+    '            [curl -sfS https://dotenvx.sh/armor | sh]',
+    '              [npm i @dotenvx/dotenvx-armor --save]',
     '',
     '                                -',
     '',
@@ -34,6 +41,26 @@ function vltBanner () {
   return `${top}\n${middle}\n${bottom}`
 }
 
+function dynamicAttempts (command, forwardedArgs) {
+  if (command === 'vlt') {
+    return [
+      ['dotenvx-armor', forwardedArgs],
+      ['dotenvx-vlt', forwardedArgs],
+      ['dotenvx-ops', forwardedArgs]
+    ]
+  }
+
+  if (command === 'ops') {
+    return [
+      ['dotenvx-armor', forwardedArgs],
+      ['dotenvx-ops', forwardedArgs],
+      ['dotenvx-vlt', forwardedArgs]
+    ]
+  }
+
+  return [[`dotenvx-${command}`, forwardedArgs]]
+}
+
 function executeDynamic (program, command, rawArgs) {
   if (!command) {
     program.outputHelp()
@@ -52,18 +79,20 @@ function executeDynamic (program, command, rawArgs) {
   const newPath = `${binPath}:${process.env.PATH}`
   const env = { ...process.env, PATH: newPath }
 
-  let spawnCommand = `dotenvx-${command}`
-  let result = childProcess.spawnSync(spawnCommand, forwardedArgs, { stdio: 'inherit', env })
-  if (command === 'ops' && result.error) {
-    spawnCommand = 'dotenvx-vlt'
-    result = childProcess.spawnSync(spawnCommand, forwardedArgs, { stdio: 'inherit', env })
+  const spawnOptions = { stdio: 'inherit', env }
+  let result
+  for (const [spawnCommand, spawnArgs] of dynamicAttempts(command, forwardedArgs)) {
+    result = childProcess.spawnSync(spawnCommand, spawnArgs, spawnOptions)
+    if (!result.error) break
   }
 
   if (result.error) {
     if (command === 'vlt') {
-      console.log(vltBanner())
+      console.log(armorBanner())
     } else if (command === 'ops') {
-      console.log(vltBanner())
+      console.log(armorBanner())
+    } else if (command === 'armor') {
+      console.log(armorBanner())
     } else {
       logger.info(`error: unknown command '${command}'`)
     }

package/src/lib/helpers/keyResolution/keyValues.js

@@ -5,7 +5,7 @@ const dotenvParse = require('./../dotenvParse')
 const keyNames = require('./keyNames')
 const readProcessKey = require('./readProcessKey')
 const readFileKey = require('./readFileKey')
-const vltKeypair = require('../cryptography/vltKeypair')
+const armorKeypair = require('../cryptography/armorKeypair')
 
 async function invertForPrivateKeyName (filepath) {
   const PUBLIC_KEY_SCHEMA = 'DOTENV_PUBLIC_KEY'
@@ -34,7 +34,7 @@ async function invertForPrivateKeyName (filepath) {
 
 async function keyValues (filepath, opts = {}) {
   let keysFilepath = opts.keysFilepath || null
-  const noVlt = opts.noVlt === true
+  const noArmor = opts.noArmor === true
   const names = keyNames(filepath)
   const publicKeyName = names.publicKeyName // DOTENV_PUBLIC_KEY_${ENVIRONMENT}
   let privateKeyName = names.privateKeyName // DOTENV_PRIVATE_KEY_${ENVIRONMENT}
@@ -71,11 +71,15 @@ async function keyValues (filepath, opts = {}) {
     }
   }
 
-  // vlt
-  if (!noVlt && !privateKey && publicKey && publicKey.length > 0) {
-    const kp = await vltKeypair(publicKey, { envFilepath: filepath, hooks: opts.keypairHooks })
+  // armor
+  if (!noArmor && !privateKey && publicKey && publicKey.length > 0) {
+    const armorOptions = { envFilepath: filepath, hooks: opts.keypairHooks }
+    if (opts.token) {
+      armorOptions.token = opts.token
+    }
+    const kp = await armorKeypair(publicKey, armorOptions)
     privateKey = kp.privateKey
-    privateKeySource = 'vlt'
+    privateKeySource = 'armor'
   }
 
   const result = {

package/src/lib/helpers/keyResolution/keyValuesFromEnvSrc.js

@@ -2,7 +2,7 @@ const path = require('path')
 
 const dotenvParse = require('./../dotenvParse')
 const readFileKeySync = require('./readFileKeySync')
-const vltKeypairSync = require('../cryptography/vltKeypairSync')
+const armorKeypairSync = require('../cryptography/armorKeypairSync')
 
 const PUBLIC_KEY_SCHEMA = 'DOTENV_PUBLIC_KEY'
 const PRIVATE_KEY_SCHEMA = 'DOTENV_PRIVATE_KEY'
@@ -25,7 +25,7 @@ function publicKeyNameFromEnvSrc (envParsed) {
 
 function keyValuesFromEnvSrc (src, privateKeyName = null, opts = {}) {
   let keysFilepath = opts.keysFilepath || null
-  const noVlt = opts.noVlt === true
+  const noArmor = opts.noArmor === true
   const processEnv = opts.processEnv || process.env
   const envParsed = dotenvParse(src)
 
@@ -52,10 +52,14 @@ function keyValuesFromEnvSrc (src, privateKeyName = null, opts = {}) {
     }
   }
 
-  if (!noVlt && !privateKeyValue && publicKeyValue && publicKeyValue.length > 0) {
-    const kp = vltKeypairSync(publicKeyValue)
+  if (!noArmor && !privateKeyValue && publicKeyValue && publicKeyValue.length > 0) {
+    const armorOptions = {}
+    if (opts.token) {
+      armorOptions.token = opts.token
+    }
+    const kp = armorKeypairSync(publicKeyValue, armorOptions)
     privateKeyValue = kp.privateKey
-    privateKeySource = 'vlt'
+    privateKeySource = 'armor'
   }
 
   const result = {

package/src/lib/helpers/keyResolution/keyValuesSync.js

@@ -5,7 +5,7 @@ const dotenvParse = require('./../dotenvParse')
 const keyNames = require('./keyNames')
 const readProcessKey = require('./readProcessKey')
 const readFileKeySync = require('./readFileKeySync')
-const vltKeypairSync = require('../cryptography/vltKeypairSync')
+const armorKeypairSync = require('../cryptography/armorKeypairSync')
 
 function invertForPrivateKeyName (filepath) {
   const PUBLIC_KEY_SCHEMA = 'DOTENV_PUBLIC_KEY'
@@ -34,7 +34,7 @@ function invertForPrivateKeyName (filepath) {
 
 function keyValuesSync (filepath, opts = {}) {
   let keysFilepath = opts.keysFilepath || null
-  const noVlt = opts.noVlt === true
+  const noArmor = opts.noArmor === true
   const names = keyNames(filepath)
   const publicKeyName = names.publicKeyName // DOTENV_PUBLIC_KEY_${ENVIRONMENT}
   let privateKeyName = names.privateKeyName // DOTENV_PRIVATE_KEY_${ENVIRONMENT}
@@ -71,16 +71,19 @@ function keyValuesSync (filepath, opts = {}) {
     }
   }
 
-  // vlt
-  if (!noVlt && !privateKey && publicKey && publicKey.length > 0) {
-    const vltOptions = { envFilepath: filepath }
+  // armor
+  if (!noArmor && !privateKey && publicKey && publicKey.length > 0) {
+    const armorOptions = { envFilepath: filepath }
+    if (opts.token) {
+      armorOptions.token = opts.token
+    }
     if (opts.noSpinner) {
-      vltOptions.noSpinner = true
+      armorOptions.noSpinner = true
     }
 
-    const kp = vltKeypairSync(publicKey, vltOptions)
+    const kp = armorKeypairSync(publicKey, armorOptions)
     privateKey = kp.privateKey
-    privateKeySource = 'vlt'
+    privateKeySource = 'armor'
   }
 
   const result = {

package/src/lib/main.d.ts

@@ -147,13 +147,20 @@ export interface DotenvConfigOptions {
   quiet?: boolean;
 
   /**
-   * Disable spinner output from child Dotenvx Ops commands.
+   * Disable spinner output from child Dotenvx Armor commands.
    *
    * @default false
    * @example require('@dotenvx/dotenvx').config({ noSpinner: true })
    */
   noSpinner?: boolean;
 
+  /**
+   * Set Armor token.
+   *
+   * @example require('@dotenvx/dotenvx').config({ token: process.env.DOTENVX_ARMOR_TOKEN })
+   */
+  token?: string;
+
   logLevel?:
     | 'error'
     | 'warn'
@@ -165,21 +172,29 @@ export interface DotenvConfigOptions {
     | 'debug';
 
   /**
-   * Turn off Dotenvx Vlt Ops features. Alias for `noVlt`.
+   * Turn off Dotenvx Armor features.
    *
    * @default false
-   * @example require('@dotenvx/dotenvx').config({ noOps: true })
+   * @example require('@dotenvx/dotenvx').config({ noArmor: true })
    */
-  noOps?: boolean;
+  noArmor?: boolean;
 
   /**
-   * Turn off Dotenvx Vlt Ops features.
+   * Turn off Dotenvx Armor features. Alias for `noArmor`.
    *
    * @default false
    * @example require('@dotenvx/dotenvx').config({ noVlt: true })
    */
   noVlt?: boolean;
 
+  /**
+   * Turn off Dotenvx Armor features. Alias for `noArmor`.
+   *
+   * @default false
+   * @example require('@dotenvx/dotenvx').config({ noOps: true })
+   */
+  noOps?: boolean;
+
 }
 
 export type DotenvConfigEnv =
@@ -248,21 +263,29 @@ export interface SetOptions {
   encrypt?: boolean;
 
   /**
-   * Turn off Dotenvx Vlt Ops features. Alias for `noVlt`.
+   * Turn off Dotenvx Armor features.
    *
    * @default false
-   * @example require('@dotenvx/dotenvx').set(key, value, { noOps: true })
+   * @example require('@dotenvx/dotenvx').set(key, value, { noArmor: true })
    */
-  noOps?: boolean;
+  noArmor?: boolean;
 
   /**
-   * Turn off Dotenvx Vlt Ops features.
+   * Turn off Dotenvx Armor features. Alias for `noArmor`.
    *
    * @default false
    * @example require('@dotenvx/dotenvx').set(key, value, { noVlt: true })
    */
   noVlt?: boolean;
 
+  /**
+   * Turn off Dotenvx Armor features. Alias for `noArmor`.
+   *
+   * @default false
+   * @example require('@dotenvx/dotenvx').set(key, value, { noOps: true })
+   */
+  noOps?: boolean;
+
 }
 
 export type SetProcessedEnv = {
@@ -333,21 +356,29 @@ export interface GetOptions {
   strict?: boolean;
 
   /**
-   * Turn off Dotenvx Vlt Ops features. Alias for `noVlt`.
+   * Turn off Dotenvx Armor features.
    *
    * @default false
-   * @example require('@dotenvx/dotenvx').get('KEY', { noOps: true })
+   * @example require('@dotenvx/dotenvx').get('KEY', { noArmor: true })
    */
-  noOps?: boolean;
+  noArmor?: boolean;
 
   /**
-   * Turn off Dotenvx Vlt Ops features.
+   * Turn off Dotenvx Armor features. Alias for `noArmor`.
    *
    * @default false
    * @example require('@dotenvx/dotenvx').get('KEY', { noVlt: true })
    */
   noVlt?: boolean;
 
+  /**
+   * Turn off Dotenvx Armor features. Alias for `noArmor`.
+   *
+   * @default false
+   * @example require('@dotenvx/dotenvx').get('KEY', { noOps: true })
+   */
+  noOps?: boolean;
+
 }
 
 /**

package/src/lib/main.js

@@ -47,8 +47,8 @@ const config = function (options = {}) {
     setLogVersion(options)
   }
 
-  // dotenvx-vlt related
-  const noVlt = resolveNoVlt(options)
+  // dotenvx-armor related
+  const noArmor = resolveNoArmor(options)
 
   try {
     let envs = buildEnvs(options)
@@ -59,8 +59,9 @@ const config = function (options = {}) {
       processedEnvs,
       readableFilepaths,
       uniqueInjectedKeys
-    } = new Run(envs, overload, processEnv, envKeysFile, noVlt, {
-      noSpinner: options.noSpinner
+    } = new Run(envs, overload, processEnv, envKeysFile, noArmor, {
+      noSpinner: options.noSpinner,
+      token: options.token
     }).runSync()
 
     let lastError
@@ -179,13 +180,13 @@ const set = function (key, value, options = {}) {
 
   const envs = buildEnvs(options)
   const envKeysFilepath = options.envKeysFile
-  const noVlt = resolveNoVlt(options)
+  const noArmor = resolveNoArmor(options)
 
   const {
     processedEnvs,
     changedFilepaths,
     unchangedFilepaths
-  } = new Sets(key, value, envs, encrypt, envKeysFilepath, noVlt).runSync()
+  } = new Sets(key, value, envs, encrypt, envKeysFilepath, noArmor).runSync()
 
   let withEncryption = ''
 
@@ -243,12 +244,12 @@ const set = function (key, value, options = {}) {
 /* @type {import('./main').get} */
 const get = function (key, options = {}) {
   const envs = buildEnvs(options)
-  const noVlt = resolveNoVlt(options)
+  const noArmor = resolveNoArmor(options)
 
   // ignore
   const ignore = options.ignore || []
 
-  const { parsed, errors } = new Get(key, envs, options.overload, options.all, options.envKeysFile, noVlt).runSync()
+  const { parsed, errors } = new Get(key, envs, options.overload, options.all, options.envKeysFile, noArmor).runSync()
 
   for (const error of errors || []) {
     if (ignore.includes(error.code)) {
@@ -313,8 +314,8 @@ const genexample = function (directory, envFile) {
 }
 
 /** @type {import('./main').keypair} */
-const keypair = function (envFile, key, envKeysFile = null, noVlt = false) {
-  const keypairs = new Keypair(envFile, envKeysFile, noVlt).runSync()
+const keypair = function (envFile, key, envKeysFile = null, noArmor = false) {
+  const keypairs = new Keypair(envFile, envKeysFile, noArmor).runSync()
   if (key) {
     return keypairs[key]
   } else {
@@ -322,9 +323,9 @@ const keypair = function (envFile, key, envKeysFile = null, noVlt = false) {
   }
 }
 
-function resolveNoVlt (options = {}) {
+function resolveNoArmor (options = {}) {
   const sesh = new Session()
-  return options.noVlt === true || options.noOps === true || sesh.noVltSync()
+  return options.noArmor === true || options.noVlt === true || options.noOps === true || (!options.token && sesh.noArmorSync())
 }
 
 module.exports = {

package/src/lib/services/decrypt.js

@@ -25,12 +25,12 @@ const dotenvParse = require('./../helpers/dotenvParse')
 const detectEncoding = require('./../helpers/detectEncoding')
 
 class Decrypt {
-  constructor (envs = [], key = [], excludeKey = [], envKeysFilepath = null, noVlt = false) {
+  constructor (envs = [], key = [], excludeKey = [], envKeysFilepath = null, noArmor = false) {
     this.envs = determine(envs, process.env)
     this.key = key
     this.excludeKey = excludeKey
     this.envKeysFilepath = envKeysFilepath
-    this.noVlt = noVlt
+    this.noArmor = noArmor
 
     this.processedEnvs = []
     this.changedFilepaths = new Set()
@@ -77,11 +77,11 @@ class Decrypt {
       const envParsed = dotenvParse(envSrc, false, false, true)
 
       const { privateKeyName } = keyNames(envFilepath)
-      const { privateKeyValue, privateKeySource } = await keyValues(envFilepath, { keysFilepath: this.envKeysFilepath, noVlt: this.noVlt })
+      const { privateKeyValue, privateKeySource } = await keyValues(envFilepath, { keysFilepath: this.envKeysFilepath, noArmor: this.noArmor })
 
       row.privateKey = privateKeyValue
       row.privateKeySource = privateKeySource
-      row.armoredPrivateKeyUsed = privateKeySource === 'vlt'
+      row.armoredPrivateKeyUsed = privateKeySource === 'armor'
       row.privateKeyName = privateKeyName
       row.changed = false // track possible changes
 

package/src/lib/services/encrypt.js

@@ -29,12 +29,12 @@ const detectEncoding = require('./../helpers/detectEncoding')
 const SAMPLE_ENV_KIT = require('./../helpers/kits/sample')
 
 class Encrypt {
-  constructor (envs = [], key = [], excludeKey = [], envKeysFilepath = null, noVlt = false, noCreate = false, token = undefined, options = {}) {
+  constructor (envs = [], key = [], excludeKey = [], envKeysFilepath = null, noArmor = false, noCreate = false, token = undefined, options = {}) {
     this.envs = determine(envs, process.env)
     this.key = key
     this.excludeKey = excludeKey
     this.envKeysFilepath = envKeysFilepath
-    this.noVlt = noVlt
+    this.noArmor = noArmor
     this.noCreate = noCreate
     this.token = token
     this.keypairHooks = options.keypairHooks
@@ -105,7 +105,7 @@ class Encrypt {
       const { publicKeyName, privateKeyName } = keyNames(envFilepath)
       const { publicKeyValue, privateKeyValue } = await keyValues(envFilepath, {
         keysFilepath: this.envKeysFilepath,
-        noVlt: this.noVlt,
+        noArmor: this.noArmor,
         keypairHooks: this.keypairHooks
       })
 
@@ -115,7 +115,7 @@ class Encrypt {
           envSrc,
           envFilepath,
           keysFilepath: this.envKeysFilepath,
-          noVlt: this.noVlt,
+          noArmor: this.noArmor,
           token: this.token,
           keypairHooks: this.keypairHooks,
           selectKeyStorage: this.selectKeyStorage

package/src/lib/services/get.js

@@ -3,26 +3,26 @@ const Errors = require('./../helpers/errors')
 const { determine } = require('./../helpers/envResolution')
 
 class Get {
-  constructor (key, envs = [], overload = false, all = false, envKeysFilepath = null, noVlt = false) {
+  constructor (key, envs = [], overload = false, all = false, envKeysFilepath = null, noArmor = false) {
     this.key = key
     this.envs = envs
     this.overload = overload
     this.all = all
     this.envKeysFilepath = envKeysFilepath
-    this.noVlt = noVlt
+    this.noArmor = noArmor
   }
 
   runSync () {
     const processEnv = { ...process.env }
     const envs = determine(this.envs, processEnv)
-    const { processedEnvs } = new Run(envs, this.overload, processEnv, this.envKeysFilepath, this.noVlt).runSync()
+    const { processedEnvs } = new Run(envs, this.overload, processEnv, this.envKeysFilepath, this.noArmor).runSync()
     return this._result(processedEnvs, processEnv)
   }
 
   async run () {
     const processEnv = { ...process.env }
     const envs = determine(this.envs, processEnv)
-    const { processedEnvs } = await new Run(envs, this.overload, processEnv, this.envKeysFilepath, this.noVlt).run()
+    const { processedEnvs } = await new Run(envs, this.overload, processEnv, this.envKeysFilepath, this.noArmor).run()
     return this._result(processedEnvs, processEnv)
   }