@dotenvx/dotenvx-vlt 0.49.0

package/src/lib/helpers/createSpinner.js

@@ -0,0 +1,101 @@
+const { getColor, bold } = require('@dotenvx/dotenvx')
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+const HIDE_CURSOR = '\u001B[?25l'
+const SHOW_CURSOR = '\u001B[?25h'
+const CLEAR_LINE = '\r\x1b[K'
+const SYMBOL_INFO = 'ℹ'
+const SYMBOL_WARN = '⚠'
+const SYMBOL_ERROR = '✖'
+const SYMBOL_SUCCESS = '✔'
+
+class Spinner {
+  text
+  interval
+  frameIndex = 0
+  symbol = getColor('blue')(FRAMES[0])
+
+  constructor (text) {
+    this.text = text
+  }
+
+  start (text) {
+    if (text) {
+      this.text = text
+    }
+    this.render()
+    this.interval = setInterval(() => this.tick(), 50)
+  }
+
+  tick () {
+    this.symbol = getColor('blue')(FRAMES[this.frameIndex++])
+    if (this.frameIndex >= FRAMES.length) this.frameIndex = 0
+    this.render()
+  }
+
+  render () {
+    process.stdout.write(CLEAR_LINE + HIDE_CURSOR + (this.symbol ? this.symbol + ' ' : '') + this.text)
+  }
+
+  succeed (text) {
+    if (text) {
+      this.text = text
+    }
+    this.symbol = getColor('green')(SYMBOL_SUCCESS)
+    this._end()
+  }
+
+  info (text) {
+    if (text) {
+      this.text = text
+    }
+    this.symbol = getColor('blue')(SYMBOL_INFO)
+    this._end()
+  }
+
+  warn (text) {
+    if (text) {
+      this.text = text
+    }
+    this.symbol = getColor('orangered')(SYMBOL_WARN)
+    this._end()
+  }
+
+  fail (text) {
+    if (text) {
+      this.text = text
+    }
+    this.symbol = getColor('red')(SYMBOL_ERROR)
+    this._end()
+  }
+
+  stop () {
+    this.symbol = ''
+    this.text = ''
+    clearInterval(this.interval)
+    process.stdout.write(CLEAR_LINE + HIDE_CURSOR + (this.symbol ? this.symbol + ' ' : '') + this.text)
+    process.stdout.write(SHOW_CURSOR)
+  }
+
+  _end () {
+    this.render()
+    clearInterval(this.interval)
+    process.stdout.write(SHOW_CURSOR + '\n')
+  }
+}
+
+const createSpinner = (initialMessage = '') => {
+  const spinner = new Spinner(initialMessage)
+
+  return {
+    start: (message) => spinner.start(message),
+    succeed: (message) => spinner.succeed(getColor('green')(message)),
+    warn: (message) => spinner.warn(getColor('orangered')(message)),
+    info: (message) => spinner.info(getColor('blue')(message)),
+    done: (message) => spinner.succeed(message),
+    fail: (message) => spinner.fail(bold(getColor('red')(message))),
+    stop: () => spinner.stop()
+  }
+}
+
+module.exports = { createSpinner, Spinner }

package/src/lib/helpers/createSpinner2.js

@@ -0,0 +1,24 @@
+const FRAMES = ['◇', '⬖', '◆', '⬗']
+const FRAME_INTERVAL_MS = 80
+
+async function createSpinner2 (options = {}) {
+  const stream = process.stderr
+  const hasCursorControls = typeof stream.cursorTo === 'function' && typeof stream.clearLine === 'function'
+  const enabled = Boolean(stream.isTTY && hasCursorControls && options.spinner !== false && !options.quiet && !options.verbose && !options.debug)
+  if (!enabled) return null
+
+  const text = options.text || 'thinking'
+  const frames = options.frames || FRAMES
+
+  const { default: yoctoSpinner } = await import('yocto-spinner')
+  return yoctoSpinner({
+    text,
+    spinner: {
+      frames,
+      interval: FRAME_INTERVAL_MS
+    },
+    stream
+  }).start()
+}
+
+module.exports = createSpinner2

package/src/lib/helpers/decryptValue.js

@@ -0,0 +1,10 @@
+const { decrypt } = require('eciesjs')
+
+function decryptValue (value, privateKey) {
+  const secret = Buffer.from(privateKey, 'hex')
+  const ciphertext = Buffer.from(value, 'base64')
+
+  return decrypt(secret, ciphertext).toString()
+}
+
+module.exports = decryptValue

package/src/lib/helpers/dotenvxProjectId.js

@@ -0,0 +1,36 @@
+const fs = require('fs')
+const path = require('path')
+const dotenvx = require('@dotenvx/dotenvx')
+const Errors = require('./errors')
+
+function dotenvxProjectId (cwd = process.cwd(), raiseErrors = true) {
+  // 1. Prefer environment variable
+  if (process.env.DOTENVX_PROJECT_ID && process.env.DOTENVX_PROJECT_ID.trim()) {
+    return process.env.DOTENVX_PROJECT_ID.trim()
+  }
+
+  // 2. Otherwise, parse .env.x contents
+  const filepath = path.join(cwd, '.env.x')
+  // file must exist
+  if (!fs.existsSync(filepath)) {
+    const filename = path.basename(filepath)
+    if (raiseErrors) {
+      throw new Errors({ filename, filepath }).envXFileMissing()
+    } else {
+      return null
+    }
+  }
+
+  if (fs.existsSync(filepath)) {
+    const src = fs.readFileSync(filepath, 'utf8')
+    const parsed = dotenvx.parse(src)
+    if (parsed.DOTENVX_PROJECT_ID && parsed.DOTENVX_PROJECT_ID.trim()) {
+      return parsed.DOTENVX_PROJECT_ID.trim()
+    }
+  }
+
+  // 3. Nothing found
+  return null
+}
+
+module.exports = dotenvxProjectId

package/src/lib/helpers/encryptValue.js

@@ -0,0 +1,9 @@
+const { encrypt } = require('eciesjs')
+
+function encryptValue (value, publicKey) {
+  const ciphertext = encrypt(publicKey, Buffer.from(value))
+
+  return Buffer.from(ciphertext, 'hex').toString('base64') // base64 encode ciphertext
+}
+
+module.exports = encryptValue

package/src/lib/helpers/errors.js

@@ -0,0 +1,30 @@
+class Errors {
+  constructor (options = {}) {
+    this.filename = options.filename
+    this.filepath = options.filepath
+  }
+
+  econnrefused () {
+    const code = 'ECONNREFUSED'
+    const message = `[${code}] connection refused`
+    const help = `[${code}] check your internet connection`
+
+    const e = new Error(message)
+    e.code = code
+    e.help = help
+    return e
+  }
+
+  envXFileMissing () {
+    const code = 'ENV_X_FILE_MISSING'
+    const message = `[${code}] missing ${this.filename} file (${this.filepath})`
+    const help = `[${code}] https://github.com/dotenvx/dotenvx/issues/664`
+
+    const e = new Error(message)
+    e.code = code
+    e.help = help
+    return e
+  }
+}
+
+module.exports = Errors

package/src/lib/helpers/formatCode.js

@@ -0,0 +1,11 @@
+function formatCode (str) {
+  const parts = []
+
+  for (let i = 0; i < str.length; i += 4) {
+    parts.push(str.substring(i, i + 4))
+  }
+
+  return parts.join('-')
+}
+
+module.exports = formatCode

package/src/lib/helpers/gitBranch.js

@@ -0,0 +1,13 @@
+const execa = require('execa')
+
+function gitBranch () {
+  try {
+    const raw = execa.sync('git', ['rev-parse', '--abbrev-ref', 'HEAD'])
+
+    return raw.stdout.toString().trim()
+  } catch (_error) {
+    return null
+  }
+}
+
+module.exports = gitBranch

package/src/lib/helpers/gitUrl.js

@@ -0,0 +1,13 @@
+const execa = require('execa')
+
+function gitUrl () {
+  try {
+    const raw = execa.sync('git', ['remote', 'get-url', 'origin'])
+
+    return raw.stdout.toString().trim()
+  } catch (_error) {
+    return null
+  }
+}
+
+module.exports = gitUrl

package/src/lib/helpers/http.js

@@ -0,0 +1,17 @@
+const { request } = require('undici')
+
+const Errors = require('./errors')
+
+async function http (url, opts = {}) {
+  try {
+    return await request(url, opts)
+  } catch (err) {
+    if (err.code === 'econnrefused') {
+      throw new Errors().econnrefused()
+    }
+
+    throw err
+  }
+}
+
+module.exports = { http }

package/src/lib/helpers/jsonToEnv.js

@@ -0,0 +1,7 @@
+function jsonToEnv (json) {
+  return Object.entries(json).map(function ([key, value]) {
+    return key + '=' + `"${value}"`
+  }).join('\n')
+}
+
+module.exports = jsonToEnv

package/src/lib/helpers/keyNamesForEnvFile.js

@@ -0,0 +1,43 @@
+const canonicalEnvFilename = require('./canonicalEnvFilename')
+
+function environment (filepath) {
+  const filename = canonicalEnvFilename(filepath)
+
+  const parts = filename.split('.')
+  const possibleEnvironmentList = [...parts.slice(2)]
+
+  if (possibleEnvironmentList.length === 0) {
+    // handle .env1 -> development1
+    return filename.replace('.env', 'development')
+  }
+
+  if (possibleEnvironmentList.length === 1) {
+    return possibleEnvironmentList[0]
+  }
+
+  if (possibleEnvironmentList.length === 2) {
+    return possibleEnvironmentList.join('_')
+  }
+
+  return possibleEnvironmentList.slice(0, 2).join('_')
+}
+
+function keyNamesForEnvFile (filepath = '.env') {
+  const filename = canonicalEnvFilename(filepath)
+
+  if (filename === '.env') {
+    return {
+      publicKeyName: 'DOTENV_PUBLIC_KEY',
+      privateKeyName: 'DOTENV_PRIVATE_KEY'
+    }
+  }
+
+  const resolvedEnvironment = environment(filename).toUpperCase()
+
+  return {
+    publicKeyName: `DOTENV_PUBLIC_KEY_${resolvedEnvironment}`,
+    privateKeyName: `DOTENV_PRIVATE_KEY_${resolvedEnvironment}`
+  }
+}
+
+module.exports = keyNamesForEnvFile

package/src/lib/helpers/keypairMetadata.js

@@ -0,0 +1,88 @@
+const path = require('path')
+const fs = require('fs')
+const execa = require('execa')
+const dotenvx = require('@dotenvx/dotenvx')
+
+const canonicalEnvFilename = require('./canonicalEnvFilename')
+
+function compact (object) {
+  return Object.entries(object).reduce((acc, [key, value]) => {
+    if (value !== undefined && value !== null && value !== '') {
+      acc[key] = value
+    }
+
+    return acc
+  }, {})
+}
+
+function gitRoot () {
+  try {
+    return execa.sync('git', ['rev-parse', '--show-toplevel']).stdout.toString().trim()
+  } catch (_error) {
+    return null
+  }
+}
+
+function normalizeFilepath (envFile) {
+  const root = gitRoot()
+  const filepath = path.resolve(envFile)
+
+  if (root) {
+    return path.relative(root, filepath).replace(/\\/g, '/')
+  }
+
+  return path.relative(process.cwd(), filepath).replace(/\\/g, '/')
+}
+
+function environment (envFile) {
+  const filename = canonicalEnvFilename(envFile)
+  const parts = filename.split('.')
+  const possibleEnvironmentList = [...parts.slice(2)]
+
+  if (possibleEnvironmentList.length === 0) {
+    return filename.replace('.env', 'development')
+  }
+
+  if (possibleEnvironmentList.length === 1) {
+    return possibleEnvironmentList[0]
+  }
+
+  if (possibleEnvironmentList.length === 2) {
+    return possibleEnvironmentList.join('_')
+  }
+
+  return possibleEnvironmentList.slice(0, 2).join('_')
+}
+
+function projectName () {
+  return path.basename(gitRoot() || process.cwd())
+}
+
+function envKeys (envFile) {
+  let src
+  try {
+    src = fs.readFileSync(envFile)
+  } catch (_error) {
+    return null
+  }
+
+  const parsed = dotenvx.parse(src, {
+    ignore: ['MISSING_PRIVATE_KEY', 'WRONG_PRIVATE_KEY', 'INVALID_PRIVATE_KEY']
+  })
+
+  if (!parsed || Object.keys(parsed).length === 0) return null
+
+  return Object.keys(parsed)
+}
+
+function keypairMetadata (envFile = '.env') {
+  return compact({
+    filepath: normalizeFilepath(envFile),
+    filename: canonicalEnvFilename(envFile),
+    environment: environment(envFile),
+    project_name: projectName(),
+    keys: envKeys(envFile)
+  })
+}
+
+module.exports = keypairMetadata

package/src/lib/helpers/likelyUpdateCommand.js

@@ -0,0 +1,33 @@
+const normalizePath = require('./normalizePath')
+const safeRealpath = require('./safeRealpath')
+
+const NPM_COMMAND = 'npm i @dotenvx/dotenvx-ops'
+const CURL_COMMAND = 'curl -sfS https://dotenvx.sh/ops | sh'
+
+function likelyUpdateCommand () {
+  const isPackaged = Boolean(process.pkg)
+  const executablePath = isPackaged ? process.execPath : (process.argv[1] || process.execPath)
+  const resolvedExecutablePath = safeRealpath(executablePath)
+  const normalizedPath = normalizePath(resolvedExecutablePath || executablePath || '')
+
+  if (
+    normalizedPath.includes('/node_modules/@dotenvx/dotenvx-ops/') ||
+    normalizedPath.includes('/node_modules/.bin/dotenvx-ops')
+  ) {
+    return NPM_COMMAND
+  }
+
+  if (
+    isPackaged ||
+    normalizedPath.endsWith('/usr/local/bin/dotenvx-ops') ||
+    normalizedPath.endsWith('/opt/homebrew/bin/dotenvx-ops') ||
+    normalizedPath.endsWith('/usr/bin/dotenvx-ops') ||
+    normalizedPath.endsWith('/bin/dotenvx-ops')
+  ) {
+    return CURL_COMMAND
+  }
+
+  return NPM_COMMAND
+}
+
+module.exports = likelyUpdateCommand

package/src/lib/helpers/localKeypair.js

@@ -0,0 +1,12 @@
+const { PrivateKey } = require('eciesjs')
+
+function localKeypair () {
+  const kp = new PrivateKey()
+
+  return {
+    public_key: kp.publicKey.toHex(),
+    private_key: kp.secret.toString('hex')
+  }
+}
+
+module.exports = localKeypair

package/src/lib/helpers/mask.js

@@ -0,0 +1,12 @@
+function mask (str, showChar = 7) {
+  if (!str || str.length < 1) {
+    return ''
+  }
+
+  const visiblePart = str.slice(0, showChar)
+  const maskedPart = '*'.repeat(str.length - showChar)
+
+  return visiblePart + maskedPart
+}
+
+module.exports = mask

package/src/lib/helpers/normalizePath.js

@@ -0,0 +1,5 @@
+function normalizePath (value) {
+  return String(value || '').replace(/\\/g, '/').toLowerCase()
+}
+
+module.exports = normalizePath

package/src/lib/helpers/normalizeToken.js

@@ -0,0 +1,5 @@
+function normalizeToken (token) {
+  return token == null ? '' : token
+}
+
+module.exports = normalizeToken

package/src/lib/helpers/openUrl.js

@@ -0,0 +1,7 @@
+const open = require('open')
+
+async function openUrl (url) {
+  return open(url, { wait: true })
+}
+
+module.exports = openUrl

package/src/lib/helpers/packageJson.js

@@ -0,0 +1,3 @@
+const { name, version, description } = require('../../../package.json')
+
+module.exports = { name, version, description }

package/src/lib/helpers/playwrightConnect.js

@@ -0,0 +1,29 @@
+const { logger } = require('@dotenvx/dotenvx')
+const { chromium } = require('playwright')
+
+const VIEWPORT_WIDTH = 1200
+const VIEWPORT_HEIGHT = 742
+const VIEWPORT = { width: VIEWPORT_WIDTH, height: VIEWPORT_HEIGHT }
+
+async function playwrightConnect (channel = 'chrome') {
+  const browser = await ensurePlaywrightBrowser(channel)
+  const context = await browser.newContext({ viewport: VIEWPORT })
+  const page = await context.newPage()
+
+  return { browser, context, page }
+}
+
+async function ensurePlaywrightBrowser (channel = 'chrome') {
+  try {
+    return await chromium.launch({ headless: false, channel })
+  } catch (err) {
+    if (String(err).includes('Executable doesn\'t exist')) {
+      logger.info('Installing chromium...')
+      const cp = require('child_process')
+      cp.execSync('npx playwright install chromium', { stdio: 'inherit' })
+      return await chromium.launch({ headless: false })
+    }
+  }
+}
+
+module.exports = playwrightConnect

package/src/lib/helpers/pluralize.js

@@ -0,0 +1,10 @@
+function pluralize (word, count) {
+  // simple pluralization: add 's' at the end
+  if (count === 0 || count > 1) {
+    return word + 's'
+  } else {
+    return word
+  }
+}
+
+module.exports = pluralize

package/src/lib/helpers/prompts.js

@@ -0,0 +1,68 @@
+const Enquirer = require('enquirer')
+
+const enquirer = new Enquirer()
+
+function choicesForSelect (choices) {
+  return choices.map(choice => {
+    if (typeof choice === 'string') return choice
+
+    return {
+      name: choice.value,
+      message: choice.name || choice.value
+    }
+  })
+}
+
+function enquirerOptions (context = {}) {
+  const options = {}
+
+  if (context.input) {
+    options.stdin = context.input
+  }
+
+  if (context.output) {
+    options.stdout = context.output
+  }
+
+  return options
+}
+
+async function select ({ message, choices }, context) {
+  const answer = await enquirer.prompt({
+    type: 'select',
+    name: 'value',
+    message,
+    choices: choicesForSelect(choices),
+    ...enquirerOptions(context)
+  })
+
+  return answer.value
+}
+
+async function input ({ message }, context) {
+  const answer = await enquirer.prompt({
+    type: 'input',
+    name: 'value',
+    message,
+    ...enquirerOptions(context)
+  })
+
+  return answer.value
+}
+
+async function password ({ message }, context) {
+  const answer = await enquirer.prompt({
+    type: 'password',
+    name: 'value',
+    message,
+    ...enquirerOptions(context)
+  })
+
+  return answer.value
+}
+
+module.exports = {
+  select,
+  input,
+  password
+}

package/src/lib/helpers/removeEnvKey.js

@@ -0,0 +1,50 @@
+const fs = require('fs')
+const path = require('path')
+
+function escapeForRegex (value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function removeEnvKey (key, keysFilepath = '.env.keys') {
+  const resolvedKeysFilepath = path.resolve(keysFilepath)
+
+  if (!fs.existsSync(resolvedKeysFilepath)) {
+    return {
+      changed: false,
+      key,
+      filepath: keysFilepath
+    }
+  }
+
+  const 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 envKeyPattern = /^\s*(?:export\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=/
+  const lines = src.length > 0 ? src.split(/\r?\n/) : []
+
+  while (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop()
+  }
+
+  const nextLines = lines.filter((line) => !keyPattern.test(line))
+  const changed = nextLines.length !== lines.length
+
+  if (changed) {
+    const hasRemainingKeys = nextLines.some((line) => envKeyPattern.test(line))
+
+    if (hasRemainingKeys) {
+      const nextSrc = `${nextLines.join(eol)}${eol}`
+      fs.writeFileSync(resolvedKeysFilepath, nextSrc, 'utf8')
+    } else {
+      fs.rmSync(resolvedKeysFilepath, { force: true })
+    }
+  }
+
+  return {
+    changed,
+    key,
+    filepath: keysFilepath
+  }
+}
+
+module.exports = removeEnvKey

package/src/lib/helpers/safeRealpath.js

@@ -0,0 +1,13 @@
+const fs = require('fs')
+
+function safeRealpath (filePath) {
+  if (!filePath) return filePath
+
+  try {
+    return fs.realpathSync(filePath)
+  } catch (e) {
+    return filePath
+  }
+}
+
+module.exports = safeRealpath