@dotenvx/dotenvx-ops 0.15.6

package/src/lib/helpers/clipboardy.js

@@ -0,0 +1,51 @@
+// based on "clipboardy" by Sindre Sorhus (https://github.com/sindresorhus/clipboardy)
+// licensed under the MIT License (see [license](https://github.com/sindresorhus/clipboardy/blob/v2.3.0/license) file for details).
+
+'use strict'
+const isWSL = require('is-wsl')
+const termux = require('./clipboardy/termux.js')
+const linux = require('./clipboardy/linux.js')
+const macos = require('./clipboardy/macos.js')
+const windows = require('./clipboardy/windows.js')
+
+const platformLib = (() => {
+  switch (process.platform) {
+    case 'darwin':
+      return macos
+    case 'win32':
+      return windows
+    case 'android':
+      if (process.env.PREFIX !== '/data/data/com.termux/files/usr') {
+        throw new Error('You need to install Termux for this module to work on Android: https://termux.com')
+      }
+
+      return termux
+    default:
+      // `process.platform === 'linux'` for WSL.
+      if (isWSL) {
+        return windows
+      }
+
+      return linux
+  }
+})()
+
+exports.write = async text => {
+  if (typeof text !== 'string') {
+    throw new TypeError(`Expected a string, got ${typeof text}`)
+  }
+
+  await platformLib.copy({ input: text })
+}
+
+exports.read = async () => platformLib.paste({ stripEof: false })
+
+exports.writeSync = text => {
+  if (typeof text !== 'string') {
+    throw new TypeError(`Expected a string, got ${typeof text}`)
+  }
+
+  platformLib.copySync({ input: text })
+}
+
+exports.readSync = () => platformLib.pasteSync({ stripEof: false }).stdout

package/src/lib/helpers/confirm.js

@@ -0,0 +1,17 @@
+const { ConfirmPrompt, isCancel } = require('@clack/core')
+
+module.exports = async (opts) => {
+  const prompt = new ConfirmPrompt({
+    active: 'Y',
+    inactive: 'N',
+    initialValue: true,
+    render () {
+      return `${opts.message} (Y/n)`
+    }
+  })
+
+  const result = await prompt.prompt()
+  if (isCancel(result)) process.exit(0)
+
+  return result
+}

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/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/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/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/packageJson.js

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

package/src/lib/helpers/smartMask.js

@@ -0,0 +1,11 @@
+const mask = require('./mask')
+
+function smartMask (str, unmask = false, showChar = 7) {
+  if (unmask) {
+    return str
+  } else {
+    return mask(str, showChar)
+  }
+}
+
+module.exports = smartMask

package/src/lib/helpers/truncate.js

@@ -0,0 +1,10 @@
+function truncate (str, showChar = 7) {
+  if (str && str.length > 0) {
+    const visiblePart = str.slice(0, showChar)
+    return visiblePart + '…'
+  } else {
+    return ''
+  }
+}
+
+module.exports = truncate

package/src/lib/main.d.ts

@@ -0,0 +1,129 @@
+import type { URL } from 'url';
+
+/**
+ * Observes a dotenvx run
+ *
+ * @see https://dotenvx.com/docs
+ * @param payload - observability payload string
+ * @returns the original payload string
+ */
+export function observe(payload: string): string;
+
+export interface DotenvConfigOptions {
+  /**
+   * Specify a custom path if your file containing environment variables is located elsewhere.
+   * Can also be an array of strings, specifying multiple paths.
+   *
+   * @default require('path').resolve(process.cwd(), '.env')
+   * @example require('@dotenvx/dotenvx').config({ path: '/custom/path/to/.env' })
+   * @example require('@dotenvx/dotenvx').config({ path: ['/path/to/first.env', '/path/to/second.env'] })
+   */
+  path?: string | string[] | URL;
+
+  /**
+   * Specify the encoding of your file containing environment variables.
+   *
+   * @default 'utf8'
+   * @example require('@dotenvx/dotenvx').config({ encoding: 'latin1' })
+   */
+  encoding?: string;
+
+  /**
+   * Override any environment variables that have already been set on your machine with values from your .env file.
+   * @default false
+   * @example require('@dotenvx/dotenvx').config({ overload: true })
+   * @alias overload
+   */
+  overload?: boolean;
+
+  /**
+   * @default false
+   * @alias override
+   */
+  override?: boolean;
+
+  /**
+   * Throw immediately if an error is encountered - like a missing .env file.
+   * @default false
+   * @example require('@dotenvx/dotenvx').config({ strict: true })
+   */
+  strict?: boolean;
+
+  /**
+   * Suppress specific errors like MISSING_ENV_FILE. The error keys can be found
+   * in src/lib/helpers/errors.js
+   * @default []
+   * @example require('@dotenvx/dotenvx').config({ ignore: ['MISSING_ENV_FILE'] })
+   */
+  ignore?: string[];
+
+  /**
+   * Specify an object to write your secrets to. Defaults to process.env environment variables.
+   *
+   * @default process.env
+   * @example const processEnv = {}; require('@dotenvx/dotenvx').config({ processEnv: processEnv })
+   */
+  processEnv?: DotenvPopulateInput;
+
+  /**
+   * Customize the path to your .env.keys file. This is useful with monorepos.
+   * @default []
+   * @example require('@dotenvx/dotenvx').config({ envKeysFile: '../../.env.keys'} })
+   */
+  envKeysFile?: string;
+
+  /**
+   * Pass the DOTENV_KEY directly to config options. Defaults to looking for process.env.DOTENV_KEY environment variable. Note this only applies to decrypting .env.vault files. If passed as null or undefined, or not passed at all, dotenv falls back to its traditional job of parsing a .env file.
+   *
+   * @default undefined
+   * @example require('@dotenvx/dotenvx').config({ DOTENV_KEY: 'dotenv://:key_1234…@dotenvx.com/vault/.env.vault?environment=production' })
+   */
+  DOTENV_KEY?: string;
+
+  /**
+   * Load a .env convention (available conventions: 'nextjs, flow')
+   */
+  convention?: string;
+
+  /**
+   * Turn on logging to help debug why certain keys or values are not being set as you expect.
+   *
+   * @default false
+   * @example require('@dotenvx/dotenvx').config({ debug: process.env.DEBUG })
+   */
+  debug?: boolean;
+
+  verbose?: boolean;
+
+  quiet?: boolean;
+
+  logLevel?:
+    | 'error'
+    | 'warn'
+    | 'success'
+    | 'successv'
+    | 'info'
+    | 'help'
+    | 'verbose'
+    | 'debug';
+}
+
+export interface DotenvConfigOutput {
+  error?: Error;
+  parsed?: DotenvParseOutput;
+}
+
+export interface DotenvPopulateInput {
+  [name: string]: string;
+}
+
+/**
+ * Loads `.env` file contents into process.env by default. If `DOTENV_KEY` is present, it smartly attempts to load encrypted `.env.vault` file contents into process.env.
+ *
+ * @see https://dotenvx.com/docs
+ *
+ * @param options - additional options. example: `{ path: './custom/path', encoding: 'latin1', debug: true, overload: false }`
+ * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
+ *
+ */
+export function config(options?: DotenvConfigOptions): DotenvConfigOutput;

package/src/lib/main.js

@@ -0,0 +1,47 @@
+const si = require('systeminformation')
+const dotenvx = require('@dotenvx/dotenvx')
+
+const Session = require('./../db/session')
+const PostObserve = require('./api/postObserve')
+
+const gitUrl = require('./helpers/gitUrl')
+const gitBranch = require('./helpers/gitBranch')
+
+const observe = async function (encoded, options = {}) {
+  const sesh = new Session() // TODO: handle scenario where constructor fails
+
+  let hostname = process.env.DOTENVX_OPS_HOSTNAME || process.env.DOTENVX_RADAR_HOSTNAME || options.hostname
+  if (!hostname) {
+    hostname = sesh.hostname()
+  }
+
+  let token = process.env.DOTENVX_OPS_TOKEN || process.env.DOTENVX_RADAR_TOKEN || options.token
+  if (!token) {
+    token = sesh.token()
+  }
+
+  const _pwd = process.cwd()
+  const _gitUrl = gitUrl()
+  const _gitBranch = gitBranch()
+
+  const system = await si.system()
+  const _systemUuid = system.uuid
+
+  const osInfo = await si.osInfo()
+  const _osPlatform = osInfo.platform
+  const _osArch = osInfo.arch
+
+  const json = await new PostObserve(hostname, token, encoded, _pwd, _gitUrl, _gitBranch, _systemUuid, _osPlatform, _osArch).run()
+
+  return json
+}
+
+const config = function (options = {}) {
+  return dotenvx.config(options)
+}
+
+module.exports = {
+  observe,
+  // dotenv proxies
+  config
+}

package/src/lib/services/logout.js

@@ -0,0 +1,28 @@
+const Session = require('./../../db/session')
+
+// api calls
+const PostLogout = require('./../../lib/api/postLogout')
+
+class Logout {
+  constructor (hostname) {
+    this.hostname = hostname
+  }
+
+  async run () {
+    const sesh = new Session()
+    const token = sesh.token()
+
+    const data = await new PostLogout(this.hostname, token).run()
+
+    const id = data.id
+    const username = data.username
+    const accessToken = data.access_token
+    const settingsDevicesUrl = `${this.hostname}/settings/devices`
+
+    sesh.logout(this.hostname, id, accessToken)
+
+    return { username, accessToken, settingsDevicesUrl }
+  }
+}
+
+module.exports = Logout

package/src/lib/services/status.js

@@ -0,0 +1,11 @@
+const Session = require('./../../db/session')
+
+class Status {
+  run () {
+    const sesh = new Session()
+    const status = sesh.status()
+    return { status }
+  }
+}
+
+module.exports = Status

package/src/lib/services/sync.js

@@ -0,0 +1,94 @@
+const fs = require('fs')
+const path = require('path')
+const si = require('systeminformation')
+const dotenvx = require('@dotenvx/dotenvx')
+
+const Session = require('./../../db/session')
+
+const gitUrl = require('./../helpers/gitUrl')
+const gitBranch = require('./../helpers/gitBranch')
+const Errors = require('./../helpers/errors')
+
+// api calls
+const PostSync = require('./../api/postSync')
+
+class Sync {
+  constructor (hostname) {
+    this.hostname = hostname
+    this.cwd = process.cwd()
+  }
+
+  async run () {
+    const sesh = new Session()
+    const token = sesh.token()
+    const devicePublicKey = sesh.devicePublicKey()
+
+    // required
+    // need to get all .env files here somehow
+    const files = this._files()
+    const payload = { files }
+    const encoded = Buffer.from(JSON.stringify(payload)).toString('base64')
+    const dotenvxProjectId = this._dotenvxProjectId()
+
+    // optional
+    const _pwd = this.cwd
+    const _gitUrl = gitUrl()
+    const _gitBranch = gitBranch()
+
+    const system = await si.system()
+    const _systemUuid = system.uuid
+
+    const osInfo = await si.osInfo()
+    const _osPlatform = osInfo.platform
+    const _osArch = osInfo.arch
+
+    const data = await new PostSync(this.hostname, token, devicePublicKey, encoded, dotenvxProjectId, _pwd, _gitUrl, _gitBranch, _systemUuid, _osPlatform, _osArch).run()
+
+    return {
+      id: data.id,
+      dotenvxProjectId: data.dotenvx_project_id,
+      projectUsernameName: data.project_username_name
+    }
+  }
+
+  _dotenvxProjectId () {
+    // 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(this.cwd, '.env.x')
+    // file must exist
+    if (!fs.existsSync(filepath)) {
+      const filename = path.basename(filepath)
+      throw new Errors({ filename, filepath }).envXFileMissing()
+    }
+
+    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
+  }
+
+  _files () {
+    const out = []
+    const filepaths = dotenvx.ls(this.cwd)
+
+    for (const fp of filepaths) {
+      const abs = path.join(this.cwd, fp)
+      const src = fs.readFileSync(abs, 'utf8')
+      out.push({ filepath: fp, src })
+    }
+
+    return out
+  }
+}
+
+module.exports = Sync