infra-kit 0.1.89 → 0.1.90

package/src/integrations/doppler/doppler-cli-auth.ts

@@ -1,25 +1,23 @@
-import process from 'node:process'
 import { $ } from 'zx'
 
-import { logger } from 'src/lib/logger'
-
 /**
- * Validate Doppler CLI installation and authentication status and throw an error if not valid
+ * Validate Doppler CLI installation and authentication status. Throws on failure
+ * so callers (CLI entry, MCP tool handler) can translate to the right surface —
+ * CLI exits non-zero; MCP returns a structured tool error instead of tearing
+ * down the server.
  */
-export const validateDopplerCliAndAuth = async () => {
+export const validateDopplerCliAndAuth = async (): Promise<void> => {
   try {
     await $`doppler --version`
   } catch (error: unknown) {
-    logger.error({ error }, 'Error: Doppler CLI is not installed.')
-    logger.error('Please install it from: https://docs.doppler.com/docs/install-cli')
-    process.exit(1)
+    throw new Error('Doppler CLI is not installed. Install it from: https://docs.doppler.com/docs/install-cli', {
+      cause: error,
+    })
   }
 
   try {
     await $`doppler me`
   } catch (error: unknown) {
-    logger.error({ error }, 'Error: Doppler CLI is not authenticated.')
-    logger.error('Please authenticate by running: doppler login')
-    process.exit(1)
+    throw new Error('Doppler CLI is not authenticated. Run: doppler login', { cause: error })
   }
 }

package/src/lib/__tests__/constants.test.ts

@@ -0,0 +1,160 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import {
+  INFRA_KIT_SESSION_VAR,
+  atomicWriteFileSync,
+  getCacheRoot,
+  getSessionCacheDir,
+  parseVarNamesFromEnvFile,
+} from '../constants'
+
+const withTmpDir = (fn: (dir: string) => void): void => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'infra-kit-test-'))
+
+  try {
+    fn(dir)
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true })
+  }
+}
+
+describe('parseVarNamesFromEnvFile', () => {
+  it('returns empty array when file does not exist', () => {
+    expect(parseVarNamesFromEnvFile('/nonexistent/path/env.sh')).toEqual([])
+  })
+
+  it('extracts var names from a standard env file', () => {
+    withTmpDir((dir) => {
+      const file = path.join(dir, 'env.sh')
+
+      fs.writeFileSync(file, 'FOO=bar\nBAZ=qux\n')
+      expect(parseVarNamesFromEnvFile(file)).toEqual(['FOO', 'BAZ'])
+    })
+  })
+
+  it('skips `set -a` / `set +a` shell directives', () => {
+    withTmpDir((dir) => {
+      const file = path.join(dir, 'env.sh')
+
+      fs.writeFileSync(file, 'set -a\nFOO=bar\nset +a\n')
+      expect(parseVarNamesFromEnvFile(file)).toEqual(['FOO'])
+    })
+  })
+
+  it('handles values that contain = characters', () => {
+    withTmpDir((dir) => {
+      const file = path.join(dir, 'env.sh')
+
+      fs.writeFileSync(file, 'CONNECTION_STRING=host=db;user=admin\nFOO=bar\n')
+      expect(parseVarNamesFromEnvFile(file)).toEqual(['CONNECTION_STRING', 'FOO'])
+    })
+  })
+
+  it('skips blank lines and lines that do not match KEY= prefix', () => {
+    withTmpDir((dir) => {
+      const file = path.join(dir, 'env.sh')
+
+      fs.writeFileSync(file, '\n# comment\nFOO=1\n\nunset BAR\nBAZ=2\n')
+      expect(parseVarNamesFromEnvFile(file)).toEqual(['FOO', 'BAZ'])
+    })
+  })
+
+  it('accepts numerics and underscores in the name but rejects names starting with digits', () => {
+    withTmpDir((dir) => {
+      const file = path.join(dir, 'env.sh')
+
+      fs.writeFileSync(file, 'API_KEY_2=a\n2FOO=b\n_INTERNAL=c\n')
+      expect(parseVarNamesFromEnvFile(file)).toEqual(['API_KEY_2', '_INTERNAL'])
+    })
+  })
+})
+
+describe('getSessionCacheDir', () => {
+  let originalSession: string | undefined
+  let originalXdg: string | undefined
+
+  beforeEach(() => {
+    originalSession = process.env[INFRA_KIT_SESSION_VAR]
+    originalXdg = process.env.XDG_CACHE_HOME
+  })
+
+  afterEach(() => {
+    if (originalSession === undefined) {
+      delete process.env[INFRA_KIT_SESSION_VAR]
+    } else {
+      process.env[INFRA_KIT_SESSION_VAR] = originalSession
+    }
+
+    if (originalXdg === undefined) {
+      delete process.env.XDG_CACHE_HOME
+    } else {
+      process.env.XDG_CACHE_HOME = originalXdg
+    }
+  })
+
+  it('throws with actionable message when INFRA_KIT_SESSION is unset', () => {
+    delete process.env[INFRA_KIT_SESSION_VAR]
+    expect(() => {
+      return getSessionCacheDir()
+    }).toThrow(/INFRA_KIT_SESSION/)
+  })
+
+  it('uses XDG_CACHE_HOME when set', () => {
+    process.env[INFRA_KIT_SESSION_VAR] = 'abc123'
+    process.env.XDG_CACHE_HOME = '/custom/cache'
+    expect(getSessionCacheDir()).toBe('/custom/cache/infra-kit/abc123')
+  })
+
+  it('falls back to ~/.cache/infra-kit/<session> when XDG_CACHE_HOME is unset', () => {
+    process.env[INFRA_KIT_SESSION_VAR] = 'xyz'
+    delete process.env.XDG_CACHE_HOME
+    expect(getSessionCacheDir()).toBe(path.join(os.homedir(), '.cache', 'infra-kit', 'xyz'))
+  })
+
+  it('getCacheRoot treats empty XDG_CACHE_HOME as unset', () => {
+    process.env.XDG_CACHE_HOME = ''
+    expect(getCacheRoot()).toBe(path.join(os.homedir(), '.cache', 'infra-kit'))
+  })
+})
+
+describe('atomicWriteFileSync', () => {
+  it('writes content with the requested mode', () => {
+    withTmpDir((dir) => {
+      const file = path.join(dir, 'secret.sh')
+
+      atomicWriteFileSync(file, 'HELLO=world\n', 0o600)
+      expect(fs.readFileSync(file, 'utf-8')).toBe('HELLO=world\n')
+
+      const mode = fs.statSync(file).mode & 0o777
+
+      expect(mode).toBe(0o600)
+    })
+  })
+
+  it('leaves no temp file behind after a successful write', () => {
+    withTmpDir((dir) => {
+      const file = path.join(dir, 'secret.sh')
+
+      atomicWriteFileSync(file, 'X=1\n', 0o600)
+
+      const leftovers = fs.readdirSync(dir).filter((name) => {
+        return name.includes('.tmp.')
+      })
+
+      expect(leftovers).toEqual([])
+    })
+  })
+
+  it('overwrites an existing file', () => {
+    withTmpDir((dir) => {
+      const file = path.join(dir, 'secret.sh')
+
+      fs.writeFileSync(file, 'OLD=1\n', { mode: 0o600 })
+      atomicWriteFileSync(file, 'NEW=2\n', 0o600)
+      expect(fs.readFileSync(file, 'utf-8')).toBe('NEW=2\n')
+    })
+  })
+})

package/src/lib/__tests__/infra-kit-config.test.ts

@@ -0,0 +1,129 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Import AFTER the mock is declared so the module picks up the mocked dep.
+import { getProjectRoot } from 'src/lib/git-utils'
+
+import { getInfraKitConfig, resetInfraKitConfigCache } from '../infra-kit-config'
+
+vi.mock('src/lib/git-utils', () => {
+  return {
+    getProjectRoot: vi.fn(),
+  }
+})
+
+const VALID_YML = `dopplerProjectName: my-project
+environments:
+  - dev
+  - staging
+taskManagerProvider: linear
+`
+
+const ALTERNATE_YML = `dopplerProjectName: other-project
+environments:
+  - dev
+taskManagerProvider: false
+`
+
+const withTmpRepo = async (fn: (tmp: string) => Promise<void>): Promise<void> => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'infra-kit-config-test-'))
+
+  vi.mocked(getProjectRoot).mockResolvedValue(tmp)
+  resetInfraKitConfigCache()
+
+  try {
+    await fn(tmp)
+  } finally {
+    resetInfraKitConfigCache()
+    fs.rmSync(tmp, { recursive: true, force: true })
+  }
+}
+
+describe('getInfraKitConfig', () => {
+  beforeEach(() => {
+    resetInfraKitConfigCache()
+  })
+
+  afterEach(() => {
+    resetInfraKitConfigCache()
+    vi.clearAllMocks()
+  })
+
+  it('reads and validates a well-formed infra-kit.yml', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.yml'), VALID_YML)
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.dopplerProjectName).toBe('my-project')
+      expect(cfg.environments).toEqual(['dev', 'staging'])
+      expect(cfg.taskManagerProvider).toBe('linear')
+    })
+  })
+
+  it('accepts taskManagerProvider: false as a literal boolean', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(path.join(tmp, 'infra-kit.yml'), ALTERNATE_YML)
+
+      const cfg = await getInfraKitConfig()
+
+      expect(cfg.taskManagerProvider).toBe(false)
+    })
+  })
+
+  it('throws when infra-kit.yml is missing', async () => {
+    await withTmpRepo(async () => {
+      await expect(getInfraKitConfig()).rejects.toThrow(/not found/)
+    })
+  })
+
+  it('throws a descriptive error on schema violations', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.yml'),
+        'dopplerProjectName: ""\nenvironments: []\ntaskManagerProvider: false\n',
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/Invalid infra-kit.yml/)
+    })
+  })
+
+  it('re-reads the file when mtime changes (long-running MCP scenario)', async () => {
+    await withTmpRepo(async (tmp) => {
+      const ymlPath = path.join(tmp, 'infra-kit.yml')
+
+      fs.writeFileSync(ymlPath, VALID_YML)
+
+      const first = await getInfraKitConfig()
+
+      expect(first.dopplerProjectName).toBe('my-project')
+
+      // Advance mtime past the previous stat to simulate an edit; write new content.
+      const future = new Date(Date.now() + 2_000)
+
+      fs.writeFileSync(ymlPath, ALTERNATE_YML)
+      fs.utimesSync(ymlPath, future, future)
+
+      const second = await getInfraKitConfig()
+
+      expect(second.dopplerProjectName).toBe('other-project')
+      expect(second.environments).toEqual(['dev'])
+    })
+  })
+
+  it('returns the cached value on repeated calls when mtime is unchanged', async () => {
+    await withTmpRepo(async (tmp) => {
+      const ymlPath = path.join(tmp, 'infra-kit.yml')
+
+      fs.writeFileSync(ymlPath, VALID_YML)
+
+      const a = await getInfraKitConfig()
+      const b = await getInfraKitConfig()
+
+      // Same object reference — no re-parse.
+      expect(a).toBe(b)
+    })
+  })
+})

package/src/lib/constants.ts

@@ -1,8 +1,8 @@
 import fs from 'node:fs'
+import os from 'node:os'
 import path from 'node:path'
 import process from 'node:process'
 
-export const ENV_CACHE_DIR = './node_modules/.cache/infra-kit'
 export const ENV_LOAD_FILE = 'env-load.sh'
 export const ENV_CLEAR_FILE = 'env-clear.sh'
 
@@ -11,29 +11,68 @@ export const INFRA_KIT_ENV_CONFIG_VAR = 'INFRA_KIT_ENV_CONFIG'
 export const INFRA_KIT_ENV_PROJECT_VAR = 'INFRA_KIT_ENV_PROJECT'
 export const INFRA_KIT_ENV_LOADED_AT_VAR = 'INFRA_KIT_ENV_LOADED_AT'
 
+/**
+ * Matches a line of the form `KEY=...` where KEY is an env-var identifier
+ * (letter or underscore, then word chars). Capture group 1 is the name. Shared
+ * between env-load (validation, var counting) and parseVarNamesFromEnvFile.
+ */
+export const ENV_VAR_LINE_PATTERN = /^([A-Z_]\w*)=/i
+
 export const parseVarNamesFromEnvFile = (filePath: string): string[] => {
   if (!fs.existsSync(filePath)) return []
 
   const content = fs.readFileSync(filePath, 'utf-8')
+  const names: string[] = []
+
+  for (const line of content.split('\n')) {
+    const match = ENV_VAR_LINE_PATTERN.exec(line)
+
+    if (match) {
+      names.push(match[1]!)
+    }
+  }
+
+  return names
+}
 
-  return content
-    .split('\n')
-    .filter((line) => {
-      return line.includes('=') && !line.startsWith('set ')
-    })
-    .map((line) => {
-      return line.split('=')[0]!
-    })
+/**
+ * Root cache dir for infra-kit across all sessions. Resolved from
+ * $XDG_CACHE_HOME when set, falling back to ~/.cache/infra-kit. Keep in sync
+ * with the shell block emitted by `infra-kit init` (src/commands/init/init.ts).
+ */
+export const getCacheRoot = (): string => {
+  const xdg = process.env.XDG_CACHE_HOME
+  const base = xdg && xdg.length > 0 ? xdg : path.join(os.homedir(), '.cache')
+
+  return path.join(base, 'infra-kit')
 }
 
 export const getSessionCacheDir = (): string => {
   const session = process.env[INFRA_KIT_SESSION_VAR]
 
   if (!session) {
-    throw new Error('INFRA_KIT_SESSION is not set. Run `source ~/.zshrc` or `infra-kit init` first.')
+    throw new Error(`${INFRA_KIT_SESSION_VAR} is not set. Run \`infra-kit init\` then \`source ~/.zshrc\`.`)
   }
 
-  return path.join(ENV_CACHE_DIR, session)
+  return path.join(getCacheRoot(), session)
+}
+
+/**
+ * Write content atomically: write to a pid-suffixed temp file in the same
+ * directory, then rename. fs.renameSync is atomic on a single filesystem, so
+ * concurrent writers can't produce a half-written secret file.
+ */
+export const atomicWriteFileSync = (filePath: string, content: string, mode: number): void => {
+  const tmpPath = `${filePath}.tmp.${process.pid}`
+
+  fs.writeFileSync(tmpPath, content, { mode })
+
+  try {
+    fs.renameSync(tmpPath, filePath)
+  } catch (error) {
+    fs.rmSync(tmpPath, { force: true })
+    throw error
+  }
 }
 
 export const WORKTREES_DIR_SUFFIX = '-worktrees'

package/src/lib/git-utils/git-utils.ts

@@ -1,3 +1,4 @@
+import path from 'node:path'
 import { $ } from 'zx'
 
 /**
@@ -20,6 +21,19 @@ export const getCurrentWorktrees = async (type: 'release' | 'feature'): Promise<
   })
 }
 
+/**
+ * Extract a release branch name from a `git worktree list` output line.
+ *
+ * Returns `null` for lines that are not release worktrees.
+ *
+ * @example
+ * releaseWorktreePredicate('/path/to/release/v1.18.22  abc1234 [release/v1.18.22]')
+ * // => 'release/v1.18.22'
+ *
+ * @example
+ * releaseWorktreePredicate('/path/to/feature/login  abc1234 [feature/login]')
+ * // => null
+ */
 const releaseWorktreePredicate = (line: string): string | null => {
   const parts = line.split(' ').filter(Boolean)
 
@@ -28,6 +42,19 @@ const releaseWorktreePredicate = (line: string): string | null => {
   return `release/${parts[0]?.split('/').pop() || ''}`
 }
 
+/**
+ * Extract a feature branch name from a `git worktree list` output line.
+ *
+ * Returns `null` for lines that are not feature worktrees.
+ *
+ * @example
+ * featureWorktreePredicate('/path/to/feature/login-page  abc1234 [feature/login-page]')
+ * // => 'feature/login-page'
+ *
+ * @example
+ * featureWorktreePredicate('/path/to/release/v1.18.22  abc1234 [release/v1.18.22]')
+ * // => null
+ */
 const featureWorktreePredicate = (line: string): string | null => {
   const parts = line.split(' ').filter(Boolean)
 
@@ -44,3 +71,12 @@ export const getProjectRoot = async (): Promise<string> => {
 
   return result.stdout.trim()
 }
+
+/**
+ * Get the current repository name (basename of the project root)
+ */
+export const getRepoName = async (): Promise<string> => {
+  const projectRoot = await getProjectRoot()
+
+  return path.basename(projectRoot)
+}

package/src/lib/git-utils/index.ts

@@ -1 +1 @@
-export { getCurrentWorktrees, getProjectRoot } from './git-utils'
+export { getCurrentWorktrees, getProjectRoot, getRepoName } from './git-utils'

package/src/lib/infra-kit-config.ts

@@ -15,29 +15,36 @@ const infraKitConfigSchema = z.object({
 
 export type InfraKitConfig = z.infer<typeof infraKitConfigSchema>
 
-let cached: Promise<InfraKitConfig> | null = null
-
-export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
-  if (!cached) {
-    cached = loadInfraKitConfig()
-  }
-
-  return cached
+interface CacheEntry {
+  mtimeMs: number
+  value: InfraKitConfig
 }
 
-const loadInfraKitConfig = async (): Promise<InfraKitConfig> => {
-  const projectRoot = await getProjectRoot()
+let cached: CacheEntry | null = null
 
+/**
+ * Read and validate infra-kit.yml. Results are cached per file mtime so the
+ * long-running MCP server picks up edits without a restart — if the user edits
+ * infra-kit.yml mid-session, the next call re-reads it.
+ */
+export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
+  const projectRoot = await getProjectRoot()
   const configPath = path.join(projectRoot, INFRA_KIT_CONFIG_FILE)
 
-  let raw: string
+  let stat: Awaited<ReturnType<typeof fs.stat>>
 
   try {
-    raw = await fs.readFile(configPath, 'utf-8')
+    stat = await fs.stat(configPath)
   } catch {
+    cached = null
     throw new Error(`infra-kit.yml not found at ${configPath}`)
   }
 
+  if (cached && cached.mtimeMs === stat.mtimeMs) {
+    return cached.value
+  }
+
+  const raw = await fs.readFile(configPath, 'utf-8')
   const parsed = yaml.parse(raw)
   const result = infraKitConfigSchema.safeParse(parsed)
 
@@ -45,5 +52,12 @@ const loadInfraKitConfig = async (): Promise<InfraKitConfig> => {
     throw new Error(`Invalid infra-kit.yml at ${configPath}: ${result.error.message}`)
   }
 
+  cached = { mtimeMs: stat.mtimeMs, value: result.data }
+
   return result.data
 }
+
+/** For tests — drops the in-memory cache. */
+export const resetInfraKitConfigCache = (): void => {
+  cached = null
+}