@dotenvx/dotenvx 1.65.2 → 1.66.0

package/CHANGELOG.md

@@ -2,7 +2,19 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
-[Unreleased](https://github.com/dotenvx/dotenvx/compare/v1.65.2...main)
+[Unreleased](https://github.com/dotenvx/dotenvx/compare/v1.66.0...main)
+
+## [1.66.0](https://github.com/dotenvx/dotenvx/compare/v1.65.3...v1.66.0) (2026-05-13)
+
+### Added
+
+* Add `dotenvx doctor` ([#815](https://github.com/dotenvx/dotenvx/pull/815))
+
+## [1.65.3](https://github.com/dotenvx/dotenvx/compare/v1.65.2...v1.65.3) (2026-05-13)
+
+### Changed
+
+* Improve spinner message blinking with simpler `--no-spinner` flag passed to ops ([#814](https://github.com/dotenvx/dotenvx/pull/814))
 
 ## [1.65.2](https://github.com/dotenvx/dotenvx/compare/v1.65.1...v1.65.2) (2026-05-13)
 

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.65.2",
+  "version": "1.66.0",
   "name": "@dotenvx/dotenvx",
   "description": "secrets for agents–from the creator of `dotenv`",
   "author": "@motdotla",

package/src/cli/actions/doctor.js

@@ -0,0 +1,22 @@
+const { logger } = require('./../../shared/logger')
+const main = require('./../../lib/main')
+
+function doctor (directory = '.') {
+  logger.debug(`directory: ${directory}`)
+
+  const findings = main.doctor(directory)
+  logger.debug(`findings: ${JSON.stringify(findings)}`)
+
+  if (findings.length === 0) {
+    logger.info('no dotenv loaders found')
+    return
+  }
+
+  logger.warn(`found ${findings.length} possible dotenv loader${findings.length === 1 ? '' : 's'}`)
+
+  for (const finding of findings) {
+    logger.info(`│ ${finding.filepath}:${finding.line}: ${finding.code}`)
+  }
+}
+
+module.exports = doctor

package/src/cli/actions/run.js

@@ -55,7 +55,7 @@ async function run () {
       uniqueInjectedKeys
     } = await new Run(envs, options.overload, process.env, options.envKeysFile, noOps, {
       beforeOpsKeypair: () => {
-        if (spinner) spinner.stop()
+        if (spinner) spinner.start('retrieving')
       },
       afterOpsKeypair: () => {
         if (spinner) spinner.start('injecting')

package/src/cli/dotenvx.js

@@ -186,6 +186,14 @@ program.command('ls')
     return require('./actions/ls').apply(this, args)
   })
 
+// dotenvx doctor
+program.command('doctor', { hidden: true })
+  .description('scan for dotenv loaders')
+  .argument('[directory]', 'directory to scan', '.')
+  .action(function (...args) {
+    return require('./actions/doctor').apply(this, args)
+  })
+
 // dotenvx login
 program.command('login')
   .description('log in to unlock ⛨ ARMORED KEYS ✦ BETA')

package/src/lib/extensions/ops.js

@@ -32,13 +32,14 @@ class Ops {
     }
   }
 
-  async keypair (publicKey) {
+  async keypair (publicKey, options = {}) {
     if (this._isForcedOff()) return {}
 
     const binary = await this._resolveBinary()
     if (!binary) return {}
 
     const args = ['keypair']
+    if (options.noSpinner) args.push('--no-spinner')
     if (publicKey) args.push(publicKey)
 
     try {
@@ -48,13 +49,14 @@ class Ops {
     }
   }
 
-  keypairSync (publicKey) {
+  keypairSync (publicKey, options = {}) {
     if (this._isForcedOff()) return {}
 
     const binary = this._resolveBinarySync()
     if (!binary) return {}
 
     const args = ['keypair']
+    if (options.noSpinner) args.push('--no-spinner')
     if (publicKey) args.push(publicKey)
 
     try {
@@ -106,9 +108,10 @@ class Ops {
 
   _execInteractive (binary, args) {
     return new Promise((resolve, reject) => {
-      const subprocess = childProcess.spawn(binary, args, {
+      const spawnOptions = {
         stdio: ['inherit', 'pipe', 'inherit']
-      })
+      }
+      const subprocess = childProcess.spawn(binary, args, spawnOptions)
       let stdout = ''
 
       subprocess.stdout.on('data', (data) => {

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

@@ -5,7 +5,11 @@ async function opsKeypair (existingPublicKey, options = {}) {
 
   let kp
   try {
-    kp = await new Ops().keypair(existingPublicKey)
+    if (options.beforeOpsKeypair || options.afterOpsKeypair) {
+      kp = await new Ops().keypair(existingPublicKey, { noSpinner: true })
+    } else {
+      kp = await new Ops().keypair(existingPublicKey)
+    }
   } finally {
     if (options.afterOpsKeypair) await options.afterOpsKeypair()
   }

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

@@ -1,7 +1,8 @@
 const Ops = require('../../extensions/ops')
 
-function opsKeypairSync (existingPublicKey) {
-  const kp = new Ops().keypairSync(existingPublicKey)
+function opsKeypairSync (existingPublicKey, options = {}) {
+  const ops = new Ops()
+  const kp = Object.keys(options).length > 0 ? ops.keypairSync(existingPublicKey, options) : ops.keypairSync(existingPublicKey)
   const publicKey = kp.public_key
   const privateKey = kp.private_key
 

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

@@ -72,7 +72,12 @@ function keyValuesSync (filepath, opts = {}) {
 
   // ops
   if (!noOps && !privateKey && publicKey && publicKey.length > 0) {
-    const kp = opsKeypairSync(publicKey)
+    const opsOptions = {}
+    if (opts.noSpinner) {
+      opsOptions.noSpinner = true
+    }
+
+    const kp = Object.keys(opsOptions).length > 0 ? opsKeypairSync(publicKey, opsOptions) : opsKeypairSync(publicKey)
     privateKey = kp.privateKey
   }
 

package/src/lib/main.d.ts

@@ -146,6 +146,14 @@ export interface DotenvConfigOptions {
 
   quiet?: boolean;
 
+  /**
+   * Disable spinner output from child Dotenvx Ops commands.
+   *
+   * @default false
+   * @example require('@dotenvx/dotenvx').config({ noSpinner: true })
+   */
+  noSpinner?: boolean;
+
   logLevel?:
     | 'error'
     | 'warn'
@@ -355,6 +363,23 @@ export function ls(
   excludeEnvFile: string | string[]
 ): string[];
 
+export type DoctorFinding = {
+  lang: string;
+  filepath: string;
+  line: number;
+  code: string;
+  msg: string;
+};
+
+/**
+ * Scan code for dotenv loaders that can conflict with dotenvx.
+ *
+ * @param directory - directory to scan
+ */
+export function doctor(
+  directory: string
+): DoctorFinding[];
+
 export type GenExampleOutput = {
   envExampleFile: string;
   envFile: string | string[];

package/src/lib/main.js

@@ -7,6 +7,7 @@ const { getColor, bold } = require('./../shared/colors')
 
 // services
 const Ls = require('./services/ls')
+const Doctor = require('./services/doctor')
 const Run = require('./services/run')
 const Sets = require('./services/sets')
 const Get = require('./services/get')
@@ -59,7 +60,9 @@ const config = function (options = {}) {
       processedEnvs,
       readableFilepaths,
       uniqueInjectedKeys
-    } = new Run(envs, overload, processEnv, envKeysFile, noOps).runSync()
+    } = new Run(envs, overload, processEnv, envKeysFile, noOps, {
+      noSpinner: options.noSpinner
+    }).runSync()
 
     let lastError
     /** @type {Record<string, string>} */
@@ -296,6 +299,10 @@ const ls = function (directory, envFile, excludeEnvFile) {
   return new Ls(directory, envFile, excludeEnvFile).run()
 }
 
+const doctor = function (directory) {
+  return new Doctor(directory).run()
+}
+
 /** @type {import('./main').genexample} */
 const genexample = function (directory, envFile) {
   return new Genexample(directory, envFile).run()
@@ -324,6 +331,7 @@ module.exports = {
   set,
   get,
   ls,
+  doctor,
   keypair,
   genexample,
   // expose for libs depending on @dotenvx/dotenvx - like dotenvx-ops

package/src/lib/services/doctor.js

@@ -0,0 +1,93 @@
+const { fdir: Fdir } = require('fdir')
+const path = require('path')
+const picomatch = require('picomatch')
+const fsx = require('./../helpers/fsx')
+
+const patterns = [
+  { lang: 'Python', file: /\.py$/, match: /load_dotenv\s*\([^)]*\)/, msg: 'found python-dotenv load call' },
+  { lang: 'Python', file: /\.py$/, match: /dotenv_values\s*\([^)]*\)/, msg: 'found python-dotenv values call' },
+
+  { lang: 'Node', file: /\.(js|cjs|mjs|ts)$/, match: /require\(['"]dotenv['"]\)\.config\s*\([^)]*\)/, msg: 'found dotenv config require call' },
+  { lang: 'Node', file: /\.(js|cjs|mjs|ts)$/, match: /import\s+['"]dotenv\/config['"]/, msg: 'found dotenv/config import' },
+  { lang: 'Node', file: /\.(js|cjs|mjs|ts)$/, match: /dotenv\.config\s*\([^)]*\)/, msg: 'found dotenv config call' },
+
+  { lang: 'Ruby', file: /\.rb$/, match: /Dotenv\.(load|overload)\s*\([^)]*\)/, msg: 'found ruby dotenv load call' },
+  { lang: 'Go', file: /\.go$/, match: /godotenv\.(Load|Overload)\s*\([^)]*\)/, msg: 'found godotenv load call' },
+  { lang: 'PHP', file: /\.php$/, match: /Dotenv\\Dotenv::create\w*\s*\([^)]*\)/, msg: 'found vlucas/phpdotenv loader' },
+
+  { lang: 'Rust', file: /\.rs$/, match: /dotenvy?::dotenv\s*\([^)]*\)/, msg: 'found Rust dotenv load call' },
+  { lang: 'Java', file: /\.java$/, match: /Dotenv\.(load|configure)\s*\([^)]*\)/, msg: 'found java-dotenv load call' },
+  { lang: 'Kotlin', file: /\.kt$/, match: /Dotenv\.(load|configure)\s*\([^)]*\)/, msg: 'found java-dotenv load call' },
+  { lang: '.NET', file: /\.(cs|fs|vb)$/, match: /(?:DotNetEnv\.)?Env\.Load\s*\([^)]*\)/, msg: 'found DotNetEnv load call' }
+]
+
+class Doctor {
+  constructor (directory = './') {
+    this.cwd = path.resolve(directory)
+    this.ignore = [
+      '**/node_modules/**',
+      '**/.git/**',
+      '**/vendor/**',
+      '**/dist/**',
+      '**/build/**',
+      '**/coverage/**',
+      '**/.next/**'
+    ]
+    this.exclude = picomatch(this.ignore)
+  }
+
+  run () {
+    const findings = []
+
+    for (const filepath of this._filepaths()) {
+      findings.push(...this._scanFile(filepath))
+    }
+
+    return findings
+  }
+
+  _filepaths () {
+    return new Fdir()
+      .withRelativePaths()
+      .exclude((dir, filepath) => this._ignored(filepath))
+      .filter((filepath) => this._patternsFor(filepath).length > 0)
+      .crawl(this.cwd)
+      .sync()
+      .sort()
+  }
+
+  _scanFile (relativeFilepath) {
+    const src = fsx.readFileXSync(path.join(this.cwd, relativeFilepath))
+    const lines = src.split(/\r?\n/)
+    const findings = []
+
+    lines.forEach((line, index) => {
+      for (const pattern of this._patternsFor(relativeFilepath)) {
+        if (pattern.match.test(line)) {
+          const match = line.match(pattern.match)
+          findings.push({
+            lang: pattern.lang,
+            filepath: relativeFilepath,
+            line: index + 1,
+            code: match[0].trim(),
+            msg: pattern.msg
+          })
+        }
+      }
+    })
+
+    return findings
+  }
+
+  _patternsFor (filepath) {
+    return patterns.filter(pattern => pattern.file.test(filepath))
+  }
+
+  _ignored (filepath) {
+    return this.exclude(filepath)
+  }
+}
+
+Doctor.patterns = patterns
+
+module.exports = Doctor

package/src/lib/services/run.js

@@ -23,6 +23,7 @@ class Run {
     this.processEnv = processEnv
     this.envKeysFilepath = envKeysFilepath
     this.noOps = noOps
+    this.noSpinner = options.noSpinner
     this.beforeOpsKeypair = options.beforeOpsKeypair
     this.afterOpsKeypair = options.afterOpsKeypair
 
@@ -136,7 +137,11 @@ class Run {
       this.readableFilepaths.add(envFilepath)
 
       const { privateKeyName } = keyNames(filepath)
-      const { privateKeyValue } = keyValuesSync(filepath, { keysFilepath: this.envKeysFilepath, noOps: this.noOps })
+      const { privateKeyValue } = keyValuesSync(filepath, {
+        keysFilepath: this.envKeysFilepath,
+        noOps: this.noOps,
+        noSpinner: this.noSpinner
+      })
 
       const {
         parsed,