@alumbwe/anvil 1.0.0 → 1.0.2

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

@@ -1,526 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,133 +0,0 @@
-/**
- * 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',
-    )
-  }
-}