@alumbwe/anvil 1.0.0

package/src/init/__tests__/init-direnv.test.ts

@@ -0,0 +1,526 @@
+import { describe, test, expect, beforeEach, afterEach, mock, spyOn } from 'bun:test'
+import type { SpawnSyncReturns } from 'child_process'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+
+import {
+  findEnvrcDirectory,
+  isDirenvAvailable,
+  getDirenvExport,
+  initializeDirenv,
+} from '../init-direnv'
+
+mock.module('../utils/logger', () => ({
+  logger: {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+  },
+}))
+
+describe('init-direnv', () => {
+  describe('findEnvrcDirectory', () => {
+    let tempDir: string
+
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'direnv-test-'))
+    })
+
+    afterEach(() => {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    })
+
+    test('returns null when no .envrc exists', () => {
+      const subDir = path.join(tempDir, 'project', 'src')
+      fs.mkdirSync(subDir, { recursive: true })
+
+      const result = findEnvrcDirectory(subDir)
+      expect(result).toBeNull()
+    })
+
+    test('finds .envrc in the current directory', () => {
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export FOO=bar')
+
+      const result = findEnvrcDirectory(tempDir)
+      expect(result).toBe(tempDir)
+    })
+
+    test('finds .envrc in a parent directory', () => {
+      const subDir = path.join(tempDir, 'project', 'src', 'components')
+      fs.mkdirSync(subDir, { recursive: true })
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export FOO=bar')
+
+      const result = findEnvrcDirectory(subDir)
+      expect(result).toBe(tempDir)
+    })
+
+    test('finds .envrc in an intermediate parent directory', () => {
+      const projectDir = path.join(tempDir, 'project')
+      const subDir = path.join(projectDir, 'src', 'components')
+      fs.mkdirSync(subDir, { recursive: true })
+      fs.writeFileSync(path.join(projectDir, '.envrc'), 'export FOO=bar')
+
+      const result = findEnvrcDirectory(subDir)
+      expect(result).toBe(projectDir)
+    })
+
+    test('stops searching at git root when no .envrc found', () => {
+      const projectDir = path.join(tempDir, 'project')
+      const subDir = path.join(projectDir, 'src')
+      fs.mkdirSync(subDir, { recursive: true })
+      fs.mkdirSync(path.join(tempDir, '.git'))
+
+      const result = findEnvrcDirectory(subDir)
+      expect(result).toBeNull()
+    })
+
+    test('finds .envrc at git root', () => {
+      const projectDir = path.join(tempDir, 'project')
+      const subDir = path.join(projectDir, 'src')
+      fs.mkdirSync(subDir, { recursive: true })
+      fs.mkdirSync(path.join(tempDir, '.git'))
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export FOO=bar')
+
+      const result = findEnvrcDirectory(subDir)
+      expect(result).toBe(tempDir)
+    })
+
+    test('does not search above git root', () => {
+      const repoDir = path.join(tempDir, 'repo')
+      const srcDir = path.join(repoDir, 'src')
+      fs.mkdirSync(srcDir, { recursive: true })
+      fs.mkdirSync(path.join(repoDir, '.git'))
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export FOO=bar')
+
+      const result = findEnvrcDirectory(srcDir)
+      expect(result).toBeNull()
+    })
+
+    test('finds .envrc in nested git repo (submodule scenario)', () => {
+      const submoduleDir = path.join(tempDir, 'packages', 'submodule')
+      const srcDir = path.join(submoduleDir, 'src')
+      fs.mkdirSync(srcDir, { recursive: true })
+      fs.mkdirSync(path.join(tempDir, '.git'))
+      fs.mkdirSync(path.join(submoduleDir, '.git'))
+      fs.writeFileSync(path.join(submoduleDir, '.envrc'), 'export FOO=bar')
+
+      const result = findEnvrcDirectory(srcDir)
+      expect(result).toBe(submoduleDir)
+    })
+
+    test('prefers closer .envrc over farther one', () => {
+      const projectDir = path.join(tempDir, 'project')
+      const subDir = path.join(projectDir, 'src')
+      fs.mkdirSync(subDir, { recursive: true })
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export ROOT=true')
+      fs.writeFileSync(path.join(projectDir, '.envrc'), 'export PROJECT=true')
+
+      const result = findEnvrcDirectory(subDir)
+      expect(result).toBe(projectDir)
+    })
+
+    test('handles non-existent start directory gracefully', () => {
+      const nonExistent = path.join(tempDir, 'does', 'not', 'exist')
+      const result = findEnvrcDirectory(nonExistent)
+      expect(result).toBeNull()
+    })
+
+    test('handles unreadable directory gracefully', () => {
+      const restrictedDir = path.join(tempDir, 'restricted')
+      fs.mkdirSync(restrictedDir)
+
+      if (os.platform() === 'win32' || process.getuid?.() === 0) return
+
+      fs.chmodSync(restrictedDir, 0o000)
+      try {
+        const result = findEnvrcDirectory(restrictedDir)
+        expect(result).toBeNull()
+      } finally {
+        fs.chmodSync(restrictedDir, 0o755)
+      }
+    })
+
+    test('resolves relative paths', () => {
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export FOO=bar')
+
+      const originalCwd = process.cwd()
+      try {
+        process.chdir(tempDir)
+        const result = findEnvrcDirectory('.')
+        expect(result).toBe(fs.realpathSync(tempDir))
+      } finally {
+        process.chdir(originalCwd)
+      }
+    })
+
+    test('handles symlinked directories', () => {
+      const actualDir = path.join(tempDir, 'actual')
+      fs.mkdirSync(actualDir)
+      fs.writeFileSync(path.join(actualDir, '.envrc'), 'export FOO=bar')
+
+      const linkDir = path.join(tempDir, 'link')
+      fs.symlinkSync(actualDir, linkDir)
+
+      const result = findEnvrcDirectory(linkDir)
+      expect(result).not.toBeNull()
+    })
+  })
+
+  describe('isDirenvAvailable', () => {
+    test('returns boolean', () => {
+      const result = isDirenvAvailable()
+      expect(typeof result).toBe('boolean')
+    })
+
+    test('returns false on Windows', () => {
+      const result = isDirenvAvailable()
+      expect(typeof result).toBe('boolean')
+      if (os.platform() === 'win32') {
+        expect(result).toBe(false)
+      }
+    })
+
+    test('returns consistent results on repeated calls', () => {
+      const result1 = isDirenvAvailable()
+      const result2 = isDirenvAvailable()
+      const result3 = isDirenvAvailable()
+
+      expect(result1).toBe(result2)
+      expect(result2).toBe(result3)
+    })
+  })
+
+  describe('getDirenvExport', () => {
+    let tempDir: string
+    let spawnSyncSpy: ReturnType<typeof spyOn>
+    let childProcess: typeof import('child_process')
+
+    beforeEach(async () => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'direnv-export-test-'))
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export FOO=bar')
+      childProcess = await import('child_process')
+      spawnSyncSpy = spyOn(childProcess, 'spawnSync')
+    })
+
+    afterEach(() => {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+      spawnSyncSpy.mockRestore()
+    })
+
+    test('returns parsed env vars on successful export', () => {
+      spawnSyncSpy.mockReturnValue({
+        status: 0,
+        stdout: JSON.stringify({ DATABASE_URL: 'postgres://localhost', API_KEY: 'secret' }),
+        stderr: '',
+        pid: 1234,
+        output: [],
+        signal: null,
+      } as SpawnSyncReturns<string>)
+
+      const result = getDirenvExport(tempDir)
+
+      expect(result).toEqual({
+        DATABASE_URL: 'postgres://localhost',
+        API_KEY: 'secret',
+      })
+    })
+
+    test('returns null values for unset variables', () => {
+      spawnSyncSpy.mockReturnValue({
+        status: 0,
+        stdout: JSON.stringify({ KEEP: 'value', REMOVE: null }),
+        stderr: '',
+        pid: 1234,
+        output: [],
+        signal: null,
+      } as SpawnSyncReturns<string>)
+
+      const result = getDirenvExport(tempDir)
+
+      expect(result).toEqual({
+        KEEP: 'value',
+        REMOVE: null,
+      })
+    })
+
+    test('returns null when direnv command fails (non-zero exit)', () => {
+      spawnSyncSpy.mockReturnValue({
+        status: 1,
+        stdout: '',
+        stderr: 'direnv: error something went wrong',
+        pid: 1234,
+        output: [],
+        signal: null,
+      } as SpawnSyncReturns<string>)
+
+      const result = getDirenvExport(tempDir)
+
+      expect(result).toBeNull()
+    })
+
+    test('returns null and warns when .envrc is blocked', () => {
+      spawnSyncSpy.mockReturnValue({
+        status: 1,
+        stdout: '',
+        stderr: 'direnv: error /path/to/.envrc is blocked. Run `direnv allow` to approve its content',
+        pid: 1234,
+        output: [],
+        signal: null,
+      } as SpawnSyncReturns<string>)
+
+      const result = getDirenvExport(tempDir)
+
+      expect(result).toBeNull()
+    })
+
+    test('returns null when stdout is empty (no env changes)', () => {
+      spawnSyncSpy.mockReturnValue({
+        status: 0,
+        stdout: '',
+        stderr: '',
+        pid: 1234,
+        output: [],
+        signal: null,
+      } as SpawnSyncReturns<string>)
+
+      const result = getDirenvExport(tempDir)
+
+      expect(result).toBeNull()
+    })
+
+    test('returns null when stdout is only whitespace', () => {
+      spawnSyncSpy.mockReturnValue({
+        status: 0,
+        stdout: '   \n\t  ',
+        stderr: '',
+        pid: 1234,
+        output: [],
+        signal: null,
+      } as SpawnSyncReturns<string>)
+
+      const result = getDirenvExport(tempDir)
+
+      expect(result).toBeNull()
+    })
+
+    test('returns null when JSON output is invalid', () => {
+      spawnSyncSpy.mockReturnValue({
+        status: 0,
+        stdout: 'not valid json {{{',
+        stderr: '',
+        pid: 1234,
+        output: [],
+        signal: null,
+      } as SpawnSyncReturns<string>)
+
+      const result = getDirenvExport(tempDir)
+
+      expect(result).toBeNull()
+    })
+
+    test('returns null when spawnSync throws', () => {
+      spawnSyncSpy.mockImplementation(() => {
+        throw new Error('spawn failed')
+      })
+
+      const result = getDirenvExport(tempDir)
+
+      expect(result).toBeNull()
+    })
+
+    test('passes correct arguments to spawnSync', () => {
+      spawnSyncSpy.mockReturnValue({
+        status: 0,
+        stdout: '{}',
+        stderr: '',
+        pid: 1234,
+        output: [],
+        signal: null,
+      } as SpawnSyncReturns<string>)
+
+      getDirenvExport(tempDir)
+
+      expect(spawnSyncSpy).toHaveBeenCalledWith('direnv', ['export', 'json'], {
+        cwd: tempDir,
+        encoding: 'utf-8',
+        timeout: 10000,
+        env: expect.objectContaining({ DIRENV_LOG_FORMAT: '' }),
+      })
+    })
+  })
+
+  describe('initializeDirenv', () => {
+    let tempDir: string
+    let spawnSyncSpy: ReturnType<typeof spyOn>
+    let childProcess: typeof import('child_process')
+    let originalEnv: NodeJS.ProcessEnv
+    let originalCwd: string
+
+    beforeEach(async () => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'direnv-init-test-'))
+      originalEnv = { ...process.env }
+      originalCwd = process.cwd()
+      childProcess = await import('child_process')
+      spawnSyncSpy = spyOn(childProcess, 'spawnSync')
+    })
+
+    afterEach(() => {
+      for (const key of Object.keys(process.env)) {
+        if (!(key in originalEnv)) {
+          delete process.env[key]
+        }
+      }
+      for (const [key, value] of Object.entries(originalEnv)) {
+        process.env[key] = value
+      }
+      process.chdir(originalCwd)
+      fs.rmSync(tempDir, { recursive: true, force: true })
+      spawnSyncSpy.mockRestore()
+    })
+
+    test('sets environment variables from direnv export', () => {
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export TEST_VAR=test_value')
+      process.chdir(tempDir)
+
+      spawnSyncSpy.mockImplementation((cmd: string, args: string[]) => {
+        if (cmd === 'sh' && args?.[1]?.includes('command -v direnv')) {
+          return {
+            status: 0,
+            stdout: '/usr/local/bin/direnv',
+            stderr: '',
+            pid: 1234,
+            output: [],
+            signal: null,
+          } as SpawnSyncReturns<string>
+        }
+        if (cmd === 'direnv' && args?.[0] === 'export') {
+          return {
+            status: 0,
+            stdout: JSON.stringify({ TEST_VAR: 'test_value' }),
+            stderr: '',
+            pid: 1234,
+            output: [],
+            signal: null,
+          } as SpawnSyncReturns<string>
+        }
+        return { status: 1, stdout: '', stderr: '', pid: 0, output: [], signal: null } as SpawnSyncReturns<string>
+      })
+
+      initializeDirenv()
+
+      expect(process.env.TEST_VAR).toBe('test_value')
+    })
+
+    test('unsets environment variables when direnv returns null', () => {
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'unset OLD_VAR')
+      process.chdir(tempDir)
+      process.env.OLD_VAR = 'should_be_removed'
+
+      spawnSyncSpy.mockImplementation((cmd: string, args: string[]) => {
+        if (cmd === 'sh' && args?.[1]?.includes('command -v direnv')) {
+          return {
+            status: 0,
+            stdout: '/usr/local/bin/direnv',
+            stderr: '',
+            pid: 1234,
+            output: [],
+            signal: null,
+          } as SpawnSyncReturns<string>
+        }
+        if (cmd === 'direnv' && args?.[0] === 'export') {
+          return {
+            status: 0,
+            stdout: JSON.stringify({ OLD_VAR: null }),
+            stderr: '',
+            pid: 1234,
+            output: [],
+            signal: null,
+          } as SpawnSyncReturns<string>
+        }
+        return { status: 1, stdout: '', stderr: '', pid: 0, output: [], signal: null } as SpawnSyncReturns<string>
+      })
+
+      initializeDirenv()
+
+      expect(process.env.OLD_VAR).toBeUndefined()
+    })
+
+    test('does nothing when direnv is not available', () => {
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export SHOULD_NOT_SET=value')
+      process.chdir(tempDir)
+
+      spawnSyncSpy.mockImplementation((cmd: string, args: string[]) => {
+        if (cmd === 'sh' && args?.[1]?.includes('command -v direnv')) {
+          return {
+            status: 1,
+            stdout: '',
+            stderr: '',
+            pid: 1234,
+            output: [],
+            signal: null,
+          } as SpawnSyncReturns<string>
+        }
+        throw new Error('direnv should not be called when not available')
+      })
+
+      initializeDirenv()
+
+      expect(process.env.SHOULD_NOT_SET).toBeUndefined()
+    })
+
+    test('does nothing when no .envrc exists', () => {
+      process.chdir(tempDir)
+
+      spawnSyncSpy.mockImplementation((cmd: string, args: string[]) => {
+        if (cmd === 'sh' && args?.[1]?.includes('command -v direnv')) {
+          return {
+            status: 0,
+            stdout: '/usr/local/bin/direnv',
+            stderr: '',
+            pid: 1234,
+            output: [],
+            signal: null,
+          } as SpawnSyncReturns<string>
+        }
+        throw new Error('direnv should not be called when no .envrc')
+      })
+
+      initializeDirenv()
+    })
+
+    test('does nothing when direnv export fails', () => {
+      fs.writeFileSync(path.join(tempDir, '.envrc'), 'export SHOULD_NOT_SET=value')
+      process.chdir(tempDir)
+
+      spawnSyncSpy.mockImplementation((cmd: string, args: string[]) => {
+        if (cmd === 'sh' && args?.[1]?.includes('command -v direnv')) {
+          return {
+            status: 0,
+            stdout: '/usr/local/bin/direnv',
+            stderr: '',
+            pid: 1234,
+            output: [],
+            signal: null,
+          } as SpawnSyncReturns<string>
+        }
+        if (cmd === 'direnv' && args?.[0] === 'export') {
+          return {
+            status: 1,
+            stdout: '',
+            stderr: 'error',
+            pid: 1234,
+            output: [],
+            signal: null,
+          } as SpawnSyncReturns<string>
+        }
+        return { status: 1, stdout: '', stderr: '', pid: 0, output: [], signal: null } as SpawnSyncReturns<string>
+      })
+
+      initializeDirenv()
+
+      expect(process.env.SHOULD_NOT_SET).toBeUndefined()
+    })
+  })
+})

package/src/init/init-app.ts

@@ -0,0 +1,34 @@
+import { initializeThemeStore } from '../hooks/use-theme'
+import { setProjectRoot } from '../project-files'
+import { initTimestampFormatter } from '../utils/helpers'
+import { enableManualThemeRefresh } from '../utils/theme-system'
+import { initAnalytics } from '../utils/analytics'
+import { getFingerprintId } from '../utils/fingerprint'
+import { initializeDirenv } from './init-direnv'
+
+export async function initializeApp(params: { cwd?: string }): Promise<void> {
+  if (params.cwd) {
+    process.chdir(params.cwd)
+  }
+  const baseCwd = process.cwd()
+  setProjectRoot(baseCwd)
+
+  // Initialize analytics before direnv, because direnv uses the logger
+  // which calls trackEvent — analytics must be ready first.
+  try {
+    initAnalytics()
+  } catch (error) {
+    console.debug('Failed to initialize analytics:', error)
+  }
+
+  // Initialize direnv environment before anything else
+  initializeDirenv()
+
+  initializeThemeStore()
+  enableManualThemeRefresh()
+  initTimestampFormatter()
+
+  // Compute the hardware-based fingerprint in the background so it's ready
+  // by the time the user finishes reading the login prompt.
+  void getFingerprintId()
+}

package/src/init/init-direnv.ts

@@ -0,0 +1,133 @@
+/**
+ * Direnv initialization - loads environment variables from .envrc at CLI startup.
+ */
+
+import { spawnSync } from 'child_process'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+
+import { logger } from '../utils/logger'
+
+/**
+ * Search up the directory tree for .envrc, stopping at git root.
+ * @internal
+ */
+export function findEnvrcDirectory(startDir: string): string | null {
+  let currentDir = path.resolve(startDir)
+  const root = path.parse(currentDir).root
+
+  while (currentDir !== root) {
+    // Read directory entries once and check for both .envrc and .git
+    let entries: string[]
+    try {
+      entries = fs.readdirSync(currentDir)
+    } catch {
+      // Directory not readable - stop searching
+      break
+    }
+
+    const hasEnvrc = entries.includes('.envrc')
+    const hasGit = entries.includes('.git')
+
+    if (hasEnvrc) {
+      return currentDir
+    }
+
+    // If this is a git root and no .envrc found, stop searching
+    if (hasGit) {
+      break
+    }
+
+    const parentDir = path.dirname(currentDir)
+    if (parentDir === currentDir) break
+    currentDir = parentDir
+  }
+
+  return null
+}
+
+/** @internal */
+export function isDirenvAvailable(): boolean {
+  if (os.platform() === 'win32') {
+    return false
+  }
+
+  try {
+    const result = spawnSync('sh', ['-c', 'command -v direnv'], {
+      encoding: 'utf-8',
+      timeout: 2000,
+    })
+    return result.status === 0 && result.stdout.trim().length > 0
+  } catch {
+    return false
+  }
+}
+
+/** @internal */
+export function getDirenvExport(envrcDir: string): Record<string, string | null> | null {
+  try {
+    const result = spawnSync('direnv', ['export', 'json'], {
+      cwd: envrcDir,
+      encoding: 'utf-8',
+      timeout: 10000,
+      env: { ...process.env, DIRENV_LOG_FORMAT: '' },
+    })
+
+    if (result.status !== 0) {
+      if (result.stderr?.includes('is blocked')) {
+        logger.warn(
+          'direnv: .envrc is blocked. Run `direnv allow` to enable.',
+        )
+      }
+      return null
+    }
+
+    const output = result.stdout.trim()
+    if (!output) {
+      return null
+    }
+
+    const envVars = JSON.parse(output) as Record<string, string | null>
+    return envVars
+  } catch (error) {
+    logger.debug(
+      { error: error instanceof Error ? error.message : String(error) },
+      'Failed to run direnv export',
+    )
+    return null
+  }
+}
+
+/** Load direnv environment into process.env. Safe to call even if direnv is not installed. */
+export function initializeDirenv(): void {
+  if (!isDirenvAvailable()) {
+    return
+  }
+
+  const envrcDir = findEnvrcDirectory(process.cwd())
+  if (!envrcDir) {
+    return
+  }
+
+  const envVars = getDirenvExport(envrcDir)
+  if (!envVars) {
+    return
+  }
+  let appliedCount = 0
+  for (const [key, value] of Object.entries(envVars)) {
+    if (value === null) {
+      delete process.env[key]
+    } else {
+      process.env[key] = value
+    }
+    appliedCount++
+  }
+
+  if (appliedCount > 0) {
+    logger.debug(
+      { envrcDir, variableCount: appliedCount },
+      'Loaded environment variables from direnv',
+    )
+  }
+}