@dotenvx/dotenvx 1.72.0 → 1.73.1

package/src/lib/helpers/upsertEnvKey.js

@@ -0,0 +1,61 @@
+const fs = require('fs')
+const path = require('path')
+
+function escapeForRegex (value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function upsertEnvKey (key, value, keysFilepath = '.env.keys') {
+  const resolvedKeysFilepath = path.resolve(keysFilepath)
+  const keyValueLine = `${key}=${value}`
+  const created = !fs.existsSync(resolvedKeysFilepath)
+
+  let src = ''
+  if (!created) {
+    src = fs.readFileSync(resolvedKeysFilepath, 'utf8')
+  }
+
+  const eol = src.includes('\r\n') ? '\r\n' : '\n'
+  const keyPattern = new RegExp(`^\\s*(?:export\\s+)?${escapeForRegex(key)}\\s*=`)
+  const lines = src.length > 0 ? src.split(/\r?\n/) : []
+
+  while (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop()
+  }
+
+  let replaced = false
+  const nextLines = []
+
+  for (const line of lines) {
+    if (keyPattern.test(line)) {
+      if (!replaced) {
+        nextLines.push(keyValueLine)
+        replaced = true
+      }
+      continue
+    }
+
+    nextLines.push(line)
+  }
+
+  if (!replaced) {
+    nextLines.push(keyValueLine)
+  }
+
+  const nextSrc = `${nextLines.join(eol)}${eol}`
+  const changed = created || nextSrc !== src
+
+  if (changed) {
+    fs.writeFileSync(resolvedKeysFilepath, nextSrc, 'utf8')
+  }
+
+  return {
+    changed,
+    key,
+    value,
+    created,
+    filepath: keysFilepath
+  }
+}
+
+module.exports = upsertEnvKey

package/src/lib/services/armorDown.js

@@ -0,0 +1,71 @@
+const prompts = require('../helpers/prompts')
+const PostArmorDown = require('../api/postArmorDown')
+const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const upsertEnvKey = require('../helpers/upsertEnvKey')
+const readEnvKey = require('../helpers/readEnvKey')
+const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
+
+class ArmorDown {
+  constructor (hostname, token, devicePublicKey, envFile = '.env', team = undefined) {
+    this.hostname = hostname
+    this.token = token
+    this.devicePublicKey = devicePublicKey
+    this.envFile = envFile
+    this.team = team
+  }
+
+  async run () {
+    const hostname = this.hostname
+    const token = this.token
+    const devicePublicKey = this.devicePublicKey
+    const envFile = this.envFile
+    const team = this.team
+
+    const {
+      publicKeyName,
+      privateKeyName
+    } = keyNamesForEnvFile(envFile)
+
+    const publicKey = readEnvKey(publicKeyName, envFile, { strict: true, ignore: ['MISSING_PRIVATE_KEY'] })
+    let json
+
+    if (team) {
+      json = await new PostArmorDown(hostname, token, devicePublicKey, publicKey, team).run()
+    } else {
+      try {
+        json = await new PostArmorDown(hostname, token, devicePublicKey, publicKey, undefined).run()
+      } catch (error) {
+        if (error.code !== 'DOTENVX_TEAM_REQUIRED') {
+          throw error
+        }
+
+        const choices = teamChoicesFromMeta(error.meta)
+
+        let team = choices[0].value
+        if (choices.length > 1) {
+          team = await prompts.select({
+            message: 'Select team',
+            choices
+          }, {
+            input: process.stdin,
+            output: process.stderr
+          })
+        }
+
+        json = await new PostArmorDown(hostname, token, devicePublicKey, publicKey, team).run()
+      }
+    }
+
+    upsertEnvKey(privateKeyName, json.private_key)
+
+    return {
+      ...json,
+      changed: json.changed,
+      privateKeyName,
+      privateKeyValue: json.private_key,
+      publicKeyValue: publicKey
+    }
+  }
+}
+
+module.exports = ArmorDown

package/src/lib/services/armorKeypair.js

@@ -0,0 +1,156 @@
+const prompts = require('../helpers/prompts')
+const PostKeypair = require('../api/postKeypair')
+const keypairMetadata = require('../helpers/keypairMetadata')
+const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
+
+const ACCESS_APPROVAL_REQUIRED = 'ACCESS_APPROVAL_REQUIRED'
+const ACCESS_APPROVAL_PENDING = 'ACCESS_APPROVAL_PENDING'
+const ACCESS_PENDING = 'ACCESS_PENDING'
+const POLL_INTERVAL = 1000
+const POLL_TIMEOUT = 5 * 60 * 1000
+
+function grantTokenFromError (error) {
+  return error.meta && error.meta.grant_token
+}
+
+function isAccessApprovalRequired (error) {
+  return error.code === ACCESS_APPROVAL_REQUIRED
+}
+
+function isAccessPending (error) {
+  return error.code === ACCESS_PENDING || error.code === ACCESS_APPROVAL_PENDING
+}
+
+function approvalUriFromError (error) {
+  if (error.meta) {
+    return error.meta.approval_uri
+  }
+
+  return error.json && error.json.error && error.json.error.approval_uri
+}
+
+async function sleep (ms) {
+  await new Promise(resolve => setTimeout(resolve, ms))
+}
+
+function approvalTimeoutError () {
+  const code = 'ACCESS_APPROVAL_TIMEOUT'
+  const error = new Error(`[${code}] approval timed out after 5 minutes`)
+  error.code = code
+  return error
+}
+
+class ArmorKeypair {
+  constructor (hostname, token, devicePublicKey, publicKey, options = {}) {
+    this.hostname = hostname
+    this.token = token
+    this.devicePublicKey = devicePublicKey
+    this.publicKey = publicKey
+    this.team = options.team
+    this.envFile = options.envFile || '.env'
+    this.metadata = options.metadata
+    this.onApprovalRequired = null
+  }
+
+  async request (team, metadata, grantToken) {
+    if (grantToken !== undefined) {
+      return await new PostKeypair(
+        this.hostname,
+        this.token,
+        this.devicePublicKey,
+        this.publicKey,
+        team,
+        metadata,
+        grantToken
+      ).run()
+    }
+
+    return await new PostKeypair(
+      this.hostname,
+      this.token,
+      this.devicePublicKey,
+      this.publicKey,
+      team,
+      metadata
+    ).run()
+  }
+
+  async requestWithApprovalPolling (team, metadata) {
+    try {
+      return await this.request(team, metadata)
+    } catch (error) {
+      if (!isAccessApprovalRequired(error)) {
+        throw error
+      }
+
+      const grantToken = grantTokenFromError(error)
+      if (!grantToken) {
+        throw error
+      }
+
+      const approvalUri = approvalUriFromError(error)
+      if (!approvalUri) {
+        throw error
+      }
+
+      if (this.onApprovalRequired) {
+        this.onApprovalRequired({ approvalUri, code: error.code })
+      }
+
+      return await this.poll(team, metadata, grantToken)
+    }
+  }
+
+  async poll (team, metadata, grantToken) {
+    const startedAt = Date.now()
+
+    while (true) {
+      try {
+        return await this.request(team, metadata, grantToken)
+      } catch (error) {
+        if (!isAccessPending(error)) {
+          throw error
+        }
+
+        if (Date.now() - startedAt >= POLL_TIMEOUT) {
+          throw approvalTimeoutError()
+        }
+
+        await sleep(POLL_INTERVAL)
+      }
+    }
+  }
+
+  async run () {
+    const metadata = keypairMetadata(this.envFile, this.metadata)
+
+    if (this.team) {
+      return await this.requestWithApprovalPolling(this.team, metadata)
+    }
+
+    try {
+      return await this.requestWithApprovalPolling(undefined, metadata)
+    } catch (error) {
+      if (error.code !== 'DOTENVX_TEAM_REQUIRED') {
+        throw error
+      }
+
+      const choices = teamChoicesFromMeta(error.meta)
+
+      let team = choices[0].value
+      if (choices.length > 1) {
+        team = await prompts.select({
+          message: 'Select team',
+          choices
+        }, {
+          input: process.stdin,
+          output: process.stderr
+        })
+      }
+
+      return await this.requestWithApprovalPolling(team, metadata)
+    }
+  }
+}
+
+module.exports = ArmorKeypair

package/src/lib/services/armorMove.js

@@ -0,0 +1,54 @@
+const prompts = require('../helpers/prompts')
+const PostArmorMove = require('../api/postArmorMove')
+const GetAccount = require('../api/getAccount')
+const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const readEnvKey = require('../helpers/readEnvKey')
+
+class ArmorMove {
+  constructor (hostname, token, devicePublicKey, envFile = '.env') {
+    this.hostname = hostname
+    this.token = token
+    this.devicePublicKey = devicePublicKey
+    this.envFile = envFile
+
+    this.team = null
+  }
+
+  async run () {
+    const hostname = this.hostname
+    const token = this.token
+    const devicePublicKey = this.devicePublicKey
+    const envFile = this.envFile
+    let team = this.team
+
+    const {
+      publicKeyName,
+      privateKeyName
+    } = keyNamesForEnvFile(envFile)
+    const publicKey = readEnvKey(publicKeyName, envFile, { strict: true, ignore: ['MISSING_PRIVATE_KEY'] })
+
+    const accountJson = await new GetAccount(hostname, token).run()
+    const choices = accountJson.organizations.map(o => ({
+      name: o.provider_slug,
+      value: o.provider_slug
+    }))
+    team = await prompts.select({
+      message: 'Select team',
+      choices
+    }, {
+      input: process.stdin,
+      output: process.stderr
+    })
+
+    const json = await new PostArmorMove(hostname, token, devicePublicKey, publicKey, team).run()
+
+    return {
+      ...json,
+      privateKeyName,
+      privateKeyValue: json.private_key,
+      publicKeyValue: publicKey
+    }
+  }
+}
+
+module.exports = ArmorMove

package/src/lib/services/armorPull.js

@@ -0,0 +1,71 @@
+const prompts = require('../helpers/prompts')
+const PostArmorPull = require('../api/postArmorPull')
+const upsertEnvKey = require('../helpers/upsertEnvKey')
+const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const readEnvKey = require('../helpers/readEnvKey')
+const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
+
+class ArmorPull {
+  constructor (hostname, token, devicePublicKey, envFile = '.env', team = undefined) {
+    this.hostname = hostname
+    this.token = token
+    this.devicePublicKey = devicePublicKey
+    this.envFile = envFile
+    this.team = team
+  }
+
+  async run () {
+    const hostname = this.hostname
+    const token = this.token
+    const devicePublicKey = this.devicePublicKey
+    const envFile = this.envFile
+    const team = this.team
+
+    const {
+      publicKeyName,
+      privateKeyName
+    } = keyNamesForEnvFile(envFile)
+
+    const publicKey = readEnvKey(publicKeyName, envFile, { strict: true, ignore: ['MISSING_PRIVATE_KEY'] })
+    let json
+
+    if (team) {
+      json = await new PostArmorPull(hostname, token, devicePublicKey, publicKey, team).run()
+    } else {
+      try {
+        json = await new PostArmorPull(hostname, token, devicePublicKey, publicKey, undefined).run()
+      } catch (error) {
+        if (error.code !== 'DOTENVX_TEAM_REQUIRED') {
+          throw error
+        }
+
+        const choices = teamChoicesFromMeta(error.meta)
+
+        let team = choices[0].value
+        if (choices.length > 1) {
+          team = await prompts.select({
+            message: 'Select team',
+            choices
+          }, {
+            input: process.stdin,
+            output: process.stderr
+          })
+        }
+
+        json = await new PostArmorPull(hostname, token, devicePublicKey, publicKey, team).run()
+      }
+    }
+
+    const result = upsertEnvKey(privateKeyName, json.private_key)
+
+    return {
+      ...json,
+      changed: result.changed,
+      privateKeyName,
+      privateKeyValue: json.private_key,
+      publicKeyValue: publicKey
+    }
+  }
+}
+
+module.exports = ArmorPull

package/src/lib/services/armorPush.js

@@ -0,0 +1,76 @@
+const { PrivateKey } = require('eciesjs')
+const prompts = require('../helpers/prompts')
+const PostArmorPush = require('../api/postArmorPush')
+const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const readEnvKey = require('../helpers/readEnvKey')
+const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
+
+function publicKeyFromPrivateKey (privateKey) {
+  try {
+    return new PrivateKey(Buffer.from(privateKey, 'hex')).publicKey.toHex()
+  } catch {
+    return ''
+  }
+}
+
+class ArmorPush {
+  constructor (hostname, token, devicePublicKey, envFile = '.env', team = undefined) {
+    this.hostname = hostname
+    this.token = token
+    this.devicePublicKey = devicePublicKey
+    this.envFile = envFile
+    this.team = team
+  }
+
+  async run () {
+    const hostname = this.hostname
+    const token = this.token
+    const devicePublicKey = this.devicePublicKey
+    const envFile = this.envFile
+    const team = this.team
+
+    const { privateKeyName } = keyNamesForEnvFile(envFile)
+
+    const privateKey = readEnvKey(privateKeyName, '.env.keys', { strict: true })
+    const publicKey = publicKeyFromPrivateKey(privateKey)
+
+    let json
+
+    if (team) {
+      json = await new PostArmorPush(hostname, token, devicePublicKey, privateKey, team).run()
+    } else {
+      try {
+        json = await new PostArmorPush(hostname, token, devicePublicKey, privateKey, undefined).run()
+      } catch (error) {
+        if (error.code !== 'DOTENVX_TEAM_REQUIRED') {
+          throw error
+        }
+
+        const choices = teamChoicesFromMeta(error.meta)
+
+        let team = choices[0].value
+        if (choices.length > 1) {
+          team = await prompts.select({
+            message: 'Select team',
+            choices
+          }, {
+            input: process.stdin,
+            output: process.stderr
+          })
+        }
+
+        json = await new PostArmorPush(hostname, token, devicePublicKey, privateKey, team).run()
+      }
+    }
+
+    return {
+      ...json,
+      changed: json.changed,
+      privateKeyName,
+      privateKeyValue: json.private_key,
+      publicKeyValue: publicKey
+    }
+  }
+}
+
+module.exports = ArmorPush

package/src/lib/services/armorUp.js

@@ -0,0 +1,73 @@
+const prompts = require('../helpers/prompts')
+const PostArmorUp = require('../api/postArmorUp')
+const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const removeEnvKey = require('../helpers/removeEnvKey')
+const readEnvKey = require('../helpers/readEnvKey')
+const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
+
+class ArmorUp {
+  constructor (hostname, token, devicePublicKey, envFile = '.env', team = undefined) {
+    this.hostname = hostname
+    this.token = token
+    this.devicePublicKey = devicePublicKey
+    this.envFile = envFile
+    this.team = team
+  }
+
+  async run () {
+    const hostname = this.hostname
+    const token = this.token
+    const devicePublicKey = this.devicePublicKey
+    const envFile = this.envFile
+    const team = this.team
+
+    const {
+      publicKeyName,
+      privateKeyName
+    } = keyNamesForEnvFile(envFile)
+
+    const publicKey = readEnvKey(publicKeyName, envFile, { strict: true, ignore: ['MISSING_PRIVATE_KEY'] })
+    const privateKey = readEnvKey(privateKeyName, '.env.keys', { strict: true, ignore: ['MISSING_KEY'] })
+
+    let json
+
+    if (team) {
+      json = await new PostArmorUp(hostname, token, devicePublicKey, publicKey, privateKey, team).run()
+    } else {
+      try {
+        json = await new PostArmorUp(hostname, token, devicePublicKey, publicKey, privateKey, undefined).run()
+      } catch (error) {
+        if (error.code !== 'DOTENVX_TEAM_REQUIRED') {
+          throw error
+        }
+
+        const choices = teamChoicesFromMeta(error.meta)
+
+        let team = choices[0].value
+        if (choices.length > 1) {
+          team = await prompts.select({
+            message: 'Select team',
+            choices
+          }, {
+            input: process.stdin,
+            output: process.stderr
+          })
+        }
+
+        json = await new PostArmorUp(hostname, token, devicePublicKey, publicKey, privateKey, team).run()
+      }
+    }
+
+    removeEnvKey(privateKeyName)
+
+    return {
+      ...json,
+      changed: json.changed,
+      privateKeyName,
+      privateKeyValue: json.private_key,
+      publicKeyValue: publicKey
+    }
+  }
+}
+
+module.exports = ArmorUp

package/src/lib/services/decrypt.js

@@ -11,7 +11,7 @@ const {
 } = require('./../helpers/envResolution')
 
 const {
-  keyNames,
+  keyNamesForEnvFile,
   keyValues
 } = require('./../helpers/keyResolution')
 
@@ -77,7 +77,7 @@ class Decrypt {
       let envSrc = await fsx.readFileX(filepath, { encoding })
       const envParsed = dotenvParse(envSrc, false, false, true)
 
-      const { privateKeyName } = keyNames(envFilepath)
+      const { privateKeyName } = keyNamesForEnvFile(envFilepath)
       const { privateKeyValue, privateKeySource } = await keyValues(envFilepath, {
         keysFilepath: this.envKeysFilepath,
         noArmor: this.noArmor,

package/src/lib/services/encrypt.js

@@ -11,7 +11,7 @@ const {
 } = require('./../helpers/envResolution')
 
 const {
-  keyNames,
+  keyNamesForEnvFile,
   keyValues
 } = require('./../helpers/keyResolution')
 
@@ -102,7 +102,7 @@ class Encrypt {
       let publicKey
       let privateKey
 
-      const { publicKeyName, privateKeyName } = keyNames(envFilepath)
+      const { publicKeyName, privateKeyName } = keyNamesForEnvFile(envFilepath)
       const { publicKeyValue, privateKeyValue } = await keyValues(envFilepath, {
         keysFilepath: this.envKeysFilepath,
         noArmor: this.noArmor,

package/src/lib/services/keypair.js

@@ -1,8 +1,6 @@
-const {
-  keyNames,
-  keyValues,
-  keyValuesSync
-} = require('./../helpers/keyResolution')
+const keyNamesForEnvFile = require('./../helpers/keyResolution/keyNamesForEnvFile')
+const keyValues = require('./../helpers/keyResolution/keyValues')
+const keyValuesSync = require('./../helpers/keyResolution/keyValuesSync')
 
 class Keypair {
   constructor (envFile = '.env', envKeysFilepath = null, noArmor = false, options = {}) {
@@ -17,7 +15,7 @@ class Keypair {
 
     const filepaths = this._filepaths()
     for (const filepath of filepaths) {
-      const { publicKeyName, privateKeyName } = keyNames(filepath)
+      const { publicKeyName, privateKeyName } = keyNamesForEnvFile(filepath)
       const { publicKeyValue, privateKeyValue } = keyValuesSync(filepath, {
         keysFilepath: this.envKeysFilepath,
         noArmor: this.noArmor,
@@ -36,7 +34,7 @@ class Keypair {
 
     const filepaths = this._filepaths()
     for (const filepath of filepaths) {
-      const { publicKeyName, privateKeyName } = keyNames(filepath)
+      const { publicKeyName, privateKeyName } = keyNamesForEnvFile(filepath)
       const { publicKeyValue, privateKeyValue } = await keyValues(filepath, {
         keysFilepath: this.envKeysFilepath,
         noArmor: this.noArmor,

package/src/lib/services/loginPoll.js

@@ -17,6 +17,7 @@ class LoginPoll {
 
         if (data.access_token) {
           sesh.login(this.hostname, data.id, data.username, data.access_token)
+          await sesh.notifyUpdate()
           return data
         }
 

package/src/lib/services/rotate.js

@@ -11,7 +11,7 @@ const {
 } = require('./../helpers/envResolution')
 
 const {
-  keyNames,
+  keyNamesForEnvFile,
   keyValues
 } = require('./../helpers/keyResolution')
 
@@ -83,7 +83,7 @@ class Rotate {
       let envSrc = await fsx.readFileX(filepath, { encoding })
       const envParsed = dotenvParse(envSrc, false, false, true)
 
-      const { publicKeyName, privateKeyName } = keyNames(envFilepath)
+      const { publicKeyName, privateKeyName } = keyNamesForEnvFile(envFilepath)
       const { privateKeyValue } = await keyValues(envFilepath, {
         keysFilepath: this.envKeysFilepath,
         noArmor: this.noArmor,

package/src/lib/services/run.js

@@ -10,7 +10,7 @@ const detectEncoding = require('./../helpers/detectEncoding')
 const detectEncodingSync = require('./../helpers/detectEncodingSync')
 
 const {
-  keyNames,
+  keyNamesForEnvFile,
   keyValues,
   keyValuesSync,
   keyValuesFromEnvSrc
@@ -147,7 +147,7 @@ class Run {
       const src = fsx.readFileXSync(filepath, { encoding })
       this.readableFilepaths.add(envFilepath)
 
-      const { privateKeyName } = keyNames(filepath)
+      const { privateKeyName } = keyNamesForEnvFile(filepath)
       const { privateKeyValue, privateKeySource } = keyValuesSync(filepath, {
         keysFilepath: this.envKeysFilepath,
         noArmor: this.noArmor,
@@ -202,7 +202,7 @@ class Run {
       const src = await fsx.readFileX(filepath, { encoding })
       this.readableFilepaths.add(envFilepath)
 
-      const { privateKeyName } = keyNames(filepath)
+      const { privateKeyName } = keyNamesForEnvFile(filepath)
       const { privateKeyValue, privateKeySource } = await keyValues(filepath, {
         keysFilepath: this.envKeysFilepath,
         noArmor: this.noArmor,