infra-kit 0.1.74 → 0.1.75

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infra-kit",
   "type": "module",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "description": "infra-kit",
   "main": "dist/cli.js",
   "module": "dist/cli.js",

package/src/commands/env-clear/env-clear.ts

@@ -3,24 +3,26 @@ import path from 'node:path'
 import process from 'node:process'
 import { z } from 'zod'
 
-import type { EnvCache } from 'src/lib/constants'
 import {
-  ENV_CACHE_DIR,
-  ENV_CACHE_FILE,
+  ENV_CLEAR_FILE,
+  ENV_LOAD_FILE,
+  getSessionCacheDir,
   INFRA_KIT_ENV_CONFIG_VAR,
   INFRA_KIT_ENV_LOADED_AT_VAR,
   INFRA_KIT_ENV_PROJECT_VAR,
+  parseVarNamesFromEnvFile,
 } from 'src/lib/constants'
 import { logger } from 'src/lib/logger'
 import type { ToolsExecutionResult } from 'src/types'
 
 /**
- * Clear previously loaded environment variables. Usage: source <(infra-kit env-clear)
+ * Clear previously loaded environment variables. Usage: env-clear (after running eval "$(infra-kit env-init)" in shell)
  */
 export const envClear = async (): Promise<ToolsExecutionResult> => {
-  const cachePath = path.join(ENV_CACHE_DIR, ENV_CACHE_FILE)
+  const cacheDir = getSessionCacheDir()
+  const envLoadPath = path.join(cacheDir, ENV_LOAD_FILE)
 
-  if (!process.env[INFRA_KIT_ENV_CONFIG_VAR]) {
+  if (!fs.existsSync(envLoadPath)) {
     logger.error('No loaded environment found. Run `env-load` first.')
 
     return {
@@ -33,46 +35,35 @@ export const envClear = async (): Promise<ToolsExecutionResult> => {
     }
   }
 
-  const cache: EnvCache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'))
-  const varNames = cache.varNames
+  const varNames = parseVarNamesFromEnvFile(envLoadPath)
 
-  // Only unset vars that are actually set in the current session
-  const activeVars = varNames.filter((v) => {
-    return v in process.env
-  })
+  // Build unset script
+  const unsetLines = [
+    ...varNames.map((v) => {
+      return `unset ${v}`
+    }),
+    `unset ${INFRA_KIT_ENV_CONFIG_VAR}`,
+    `unset ${INFRA_KIT_ENV_PROJECT_VAR}`,
+    `unset ${INFRA_KIT_ENV_LOADED_AT_VAR}`,
+  ]
 
-  if (activeVars.length === 0) {
-    fs.unlinkSync(cachePath)
-    logger.info('Current session is clear, no environment variables to unset.')
+  // Write unset script to cache
+  const clearFilePath = path.resolve(cacheDir, ENV_CLEAR_FILE)
 
-    return {
-      content: [
-        {
-          type: 'text',
-          text: 'Current session is clear, no environment variables to unset.',
-        },
-      ],
-    }
-  }
+  fs.mkdirSync(cacheDir, { recursive: true })
+  fs.writeFileSync(clearFilePath, `${unsetLines.join('\n')}\n`)
 
-  // Output unset statements for shell sourcing
-  for (const varName of activeVars) {
-    process.stdout.write(`unset ${varName}\n`)
-  }
-  process.stdout.write(`unset ${INFRA_KIT_ENV_CONFIG_VAR}\n`)
-  process.stdout.write(`unset ${INFRA_KIT_ENV_PROJECT_VAR}\n`)
-  process.stdout.write(`unset ${INFRA_KIT_ENV_LOADED_AT_VAR}\n`)
+  // REQUIRED
+  process.stdout.write(`${clearFilePath}\n`)
 
-  // Remove cache file
-  fs.unlinkSync(cachePath)
+  // Remove env load file so env-clear can detect "no env loaded" next time
+  fs.unlinkSync(envLoadPath)
 
-  logger.info(`Cleared ${activeVars.length} environment variables`)
+  logger.info(`Cleared ${varNames.length} environment variables`)
 
   const structuredContent = {
-    variableCount: activeVars.length,
-    unsetStatements: activeVars.map((v) => {
-      return `unset ${v}`
-    }),
+    variableCount: varNames.length,
+    unsetStatements: unsetLines,
   }
 
   return {
@@ -89,7 +80,8 @@ export const envClear = async (): Promise<ToolsExecutionResult> => {
 // MCP Tool Registration
 export const envClearMcpTool = {
   name: 'env-clear',
-  description: 'Clear previously loaded environment variables. Usage: source <(infra-kit env-clear)',
+  description:
+    'Clear previously loaded environment variables. Usage: env-clear (after running eval "$(infra-kit env-init)" in shell)',
   inputSchema: {},
   outputSchema: {
     variableCount: z.number().describe('Number of variables cleared'),

package/src/commands/env-init/env-init.ts

@@ -0,0 +1,83 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+
+import { logger } from 'src/lib/logger'
+
+const MARKER_COMMENT = '# infra-kit shell functions'
+
+/**
+ * Append infra-kit shell functions directly to .zshrc.
+ */
+export const envInit = async (): Promise<void> => {
+  const zshrcPath = path.join(os.homedir(), '.zshrc')
+  const binPath = getBinPath()
+
+  if (!fs.existsSync(binPath)) {
+    logger.error(`Could not find infra-kit binary at ${binPath}`)
+
+    return
+  }
+
+  const shellBlock = buildShellBlock(binPath)
+
+  if (fs.existsSync(zshrcPath)) {
+    const content = fs.readFileSync(zshrcPath, 'utf-8')
+    const cleaned = removeExistingBlock(content)
+
+    fs.writeFileSync(zshrcPath, cleaned)
+  }
+
+  fs.appendFileSync(zshrcPath, `\n${shellBlock}\n`)
+  logger.info(`Added infra-kit shell functions to ${zshrcPath}`)
+  logger.info('Run `source ~/.zshrc` or open a new terminal to activate.')
+}
+
+const getBinPath = (): string => {
+  // resolve the absolute path to the infra-kit binary
+  return path.resolve(path.join(path.dirname(process.argv[1]!), 'cli.js'))
+}
+
+const isBlockLine = (line: string): boolean => {
+  return (
+    line.startsWith('#') ||
+    line.startsWith('env-load') ||
+    line.startsWith('env-clear') ||
+    line.startsWith('if ') ||
+    line.startsWith('  export INFRA_KIT_SESSION') ||
+    line.startsWith('fi')
+  )
+}
+
+const removeExistingBlock = (content: string): string => {
+  const markerIdx = content.indexOf(MARKER_COMMENT)
+
+  if (markerIdx === -1) return content
+
+  const before = content.slice(0, markerIdx).replace(/\n+$/, '')
+  const afterLines = content.slice(markerIdx).split('\n')
+
+  let i = 0
+
+  while (i < afterLines.length && isBlockLine(afterLines[i]!)) {
+    i++
+  }
+
+  const remaining = afterLines.slice(i).join('\n')
+
+  return before + (remaining ? `\n${remaining}` : '')
+}
+
+const buildShellBlock = (binPath: string): string => {
+  const runCmd = `node ${binPath}`
+
+  return [
+    MARKER_COMMENT,
+    'if [[ -z "${INFRA_KIT_SESSION}" ]]; then',
+    '  export INFRA_KIT_SESSION=$(head -c 4 /dev/urandom | xxd -p)',
+    'fi',
+    `env-load() { local f; f=$(${runCmd} env-load "$@") && source "$f"; }`,
+    `env-clear() { local f; f=$(${runCmd} env-clear) && source "$f"; }`,
+  ].join('\n')
+}

package/src/commands/env-init/index.ts

@@ -0,0 +1 @@
+export { envInit } from './env-init'

package/src/commands/env-load/env-load.ts

@@ -1,3 +1,4 @@
+import select from '@inquirer/select'
 import fs from 'node:fs'
 import path from 'node:path'
 import process from 'node:process'
@@ -6,19 +7,21 @@ import { $ } from 'zx'
 
 import { validateDopplerCliAndAuth } from 'src/integrations/doppler'
 import { getDopplerProject } from 'src/integrations/doppler/doppler-project'
-import type { EnvCache } from 'src/lib/constants'
+import { commandEcho } from 'src/lib/command-echo'
 import {
-  ENV_CACHE_DIR,
-  ENV_CACHE_FILE,
+  ENV_LOAD_FILE,
+  ENVs,
   INFRA_KIT_ENV_CONFIG_VAR,
   INFRA_KIT_ENV_LOADED_AT_VAR,
   INFRA_KIT_ENV_PROJECT_VAR,
+  getSessionCacheDir,
 } from 'src/lib/constants'
 import { logger } from 'src/lib/logger'
 import type { ToolsExecutionResult } from 'src/types'
 
 interface EnvLoadArgs {
-  config: string
+  config?: string
+  quiet?: boolean
 }
 
 /**
@@ -27,44 +30,66 @@ interface EnvLoadArgs {
 export const envLoad = async (args: EnvLoadArgs): Promise<ToolsExecutionResult> => {
   await validateDopplerCliAndAuth()
 
-  const { config } = args
+  const { config, quiet } = args
+
+  commandEcho.start('env-load')
+
+  let selectedConfig = ''
+
+  if (config) {
+    selectedConfig = config
+  } else {
+    commandEcho.setInteractive()
+    selectedConfig = await select({
+      message: 'Select environment config',
+      choices: ENVs.map((env) => {
+        return { name: env, value: env }
+      }),
+    })
+  }
+
+  commandEcho.addOption('--config', selectedConfig)
 
   const project = await getDopplerProject()
 
-  const result = await $`doppler secrets download --no-file --format env --project ${project} --config ${config}`
+  $.quiet = true
+  const result =
+    await $`doppler secrets download --no-file --format env --project ${project} --config ${selectedConfig}`
+
+  $.quiet = false
   const envContent = result.stdout.trim()
 
-  // Output shell-sourceable format
-  process.stdout.write('set -a\n')
-  process.stdout.write(`${envContent}\n`)
-  process.stdout.write('set +a\n')
-  process.stdout.write(`export ${INFRA_KIT_ENV_CONFIG_VAR}=${config}\n`)
-  process.stdout.write(`export ${INFRA_KIT_ENV_PROJECT_VAR}=${project}\n`)
-  process.stdout.write(`export ${INFRA_KIT_ENV_LOADED_AT_VAR}=${new Date().toISOString()}\n`)
-
-  // Extract variable names and save to cache
-  const varNames = envContent
-    .split('\n')
-    .filter((line) => {
-      return line.includes('=')
-    })
-    .map((line) => {
-      return line.split('=')[0]!
-    })
+  // Build env file content in dotenv format
+  const loadedAt = new Date().toISOString()
+  const envFileLines = [
+    'set -a',
+    envContent,
+    `${INFRA_KIT_ENV_CONFIG_VAR}=${selectedConfig}`,
+    `${INFRA_KIT_ENV_PROJECT_VAR}=${project}`,
+    `${INFRA_KIT_ENV_LOADED_AT_VAR}=${loadedAt}`,
+    'set +a',
+  ]
 
-  const cachePath = path.join(ENV_CACHE_DIR, ENV_CACHE_FILE)
+  // Write env file to cache
+  const cacheDir = getSessionCacheDir()
+  const envFilePath = path.resolve(cacheDir, ENV_LOAD_FILE)
 
-  const cache: EnvCache = { config, loadedAt: new Date().toISOString(), varNames }
+  fs.mkdirSync(cacheDir, { recursive: true })
+  fs.writeFileSync(envFilePath, `${envFileLines.join('\n')}\n`)
 
-  fs.mkdirSync(ENV_CACHE_DIR, { recursive: true })
-  fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2))
+  // REQUIRED
+  process.stdout.write(`${envFilePath}\n`)
 
-  logger.info(`Loaded ${varNames.length} variables from ${project}/${config}`)
+  const varCount = envContent.split('\n').filter((line) => line.includes('=')).length
+
+  if (!quiet) {
+    logger.info(`Loaded ${varCount} variables from ${project}/${selectedConfig}`)
+  }
 
   const structuredContent = {
-    variableCount: varNames.length,
+    variableCount: varCount,
     project,
-    config,
+    config: selectedConfig,
   }
 
   return {
@@ -81,7 +106,8 @@ export const envLoad = async (args: EnvLoadArgs): Promise<ToolsExecutionResult>
 // MCP Tool Registration
 export const envLoadMcpTool = {
   name: 'env-load',
-  description: 'Load environment variables from Doppler for a given config. Usage: source <(infra-kit env-load -c dev)',
+  description:
+    'Load environment variables from Doppler for a given config. Usage: env-load -c dev (after running eval "$(infra-kit env-init)" in shell)',
   inputSchema: {
     config: z.string().describe('Environment config name to load (e.g. dev, arthur, renana)'),
   },

package/src/commands/env-status/env-status.ts

@@ -1,18 +1,18 @@
-import fs from 'node:fs'
 import path from 'node:path'
 import process from 'node:process'
 import { z } from 'zod'
 
 import { validateDopplerCliAndAuth } from 'src/integrations/doppler'
 import { getDopplerProject } from 'src/integrations/doppler/doppler-project'
-import type { EnvCache } from 'src/lib/constants'
 import {
-  ENV_CACHE_DIR,
-  ENV_CACHE_FILE,
+  ENV_LOAD_FILE,
   ENVs,
   INFRA_KIT_ENV_CONFIG_VAR,
   INFRA_KIT_ENV_LOADED_AT_VAR,
   INFRA_KIT_ENV_PROJECT_VAR,
+  INFRA_KIT_SESSION_VAR,
+  getSessionCacheDir,
+  parseVarNamesFromEnvFile,
 } from 'src/lib/constants'
 import { logger } from 'src/lib/logger'
 import type { ToolsExecutionResult } from 'src/types'
@@ -30,8 +30,11 @@ export const envStatus = async (): Promise<ToolsExecutionResult> => {
   logger.info(`  Detected Project: ${project}`)
   logger.info(`  Available Configs: ${ENVs.join(', ')}`)
 
-  // Check session-loaded vars
-  const cachePath = path.join(ENV_CACHE_DIR, ENV_CACHE_FILE)
+  // Check session-loaded vars — getSessionCacheDir() throws if INFRA_KIT_SESSION is unset
+  const cacheDir = getSessionCacheDir()
+
+  const sessionId = process.env[INFRA_KIT_SESSION_VAR]!
+  const envLoadPath = path.join(cacheDir, ENV_LOAD_FILE)
 
   let sessionLoadedCount = 0
   let sessionTotalCount = 0
@@ -40,11 +43,11 @@ export const envStatus = async (): Promise<ToolsExecutionResult> => {
   const sessionLoadedAt = process.env[INFRA_KIT_ENV_LOADED_AT_VAR] ?? null
 
   if (sessionConfig) {
-    if (fs.existsSync(cachePath)) {
-      const cache: EnvCache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'))
+    const varNames = parseVarNamesFromEnvFile(envLoadPath)
 
-      sessionTotalCount = cache.varNames.length
-      sessionLoadedCount = cache.varNames.filter((v) => {
+    if (varNames.length > 0) {
+      sessionTotalCount = varNames.length
+      sessionLoadedCount = varNames.filter((v) => {
         return v in process.env
       }).length
     }
@@ -52,6 +55,7 @@ export const envStatus = async (): Promise<ToolsExecutionResult> => {
     logger.info(
       `  Session: ${sessionLoadedCount} of ${sessionTotalCount} vars loaded (project: ${sessionProject}, config: ${sessionConfig}, loaded at: ${sessionLoadedAt})`,
     )
+    logger.info(`  Session ID: ${sessionId}`)
   } else {
     logger.info('  Session: no env loaded')
   }
@@ -60,6 +64,7 @@ export const envStatus = async (): Promise<ToolsExecutionResult> => {
     authenticated: true,
     project,
     configs: ENVs,
+    sessionId,
     sessionLoadedCount,
     sessionTotalCount,
     sessionConfig,
@@ -87,6 +92,7 @@ export const envStatusMcpTool = {
     authenticated: z.boolean().describe('Whether the user is authenticated'),
     project: z.string().describe('Detected Doppler project name'),
     configs: z.array(z.string()).describe('Available environment configs'),
+    sessionId: z.string().describe('Current terminal session ID'),
     sessionLoadedCount: z.number().describe('Number of cached vars active in the current session'),
     sessionTotalCount: z.number().describe('Total number of cached var names'),
     sessionConfig: z.string().nullable().describe('Doppler config name of the loaded session'),

package/src/entry/cli.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander'
 
 import { doctor } from 'src/commands/doctor'
 import { envClear } from 'src/commands/env-clear'
+import { envInit } from 'src/commands/env-init'
 import { envList } from 'src/commands/env-list'
 import { envLoad } from 'src/commands/env-load'
 import { envStatus } from 'src/commands/env-status'
@@ -18,10 +19,6 @@ import { worktreesAdd } from 'src/commands/worktrees-add'
 import { worktreesList } from 'src/commands/worktrees-list'
 import { worktreesRemove } from 'src/commands/worktrees-remove'
 import { worktreesSync } from 'src/commands/worktrees-sync'
-import { loadEnvFromGitRoot } from 'src/lib/load-env'
-
-// Load .env before anything else
-await loadEnvFromGitRoot()
 
 const program = new Command()
 
@@ -177,17 +174,25 @@ program
     await envList()
   })
 
+program
+  .command('env-init')
+  .description('Set up shell functions for env-load/env-clear in .zshrc')
+  .action(async () => {
+    await envInit()
+  })
+
 program
   .command('env-load')
-  .description('Load environment variables from Doppler. Usage: source <(infra-kit env-load -c dev)')
-  .requiredOption('-c, --config <config>', 'Environment config name to load (e.g. dev, arthur)')
+  .description('Load environment variables from Doppler. Usage: env-load -c dev (after shell init)')
+  .option('-c, --config <config>', 'Environment config name to load (e.g. dev, arthur)')
+  .option('-q, --quiet', 'Suppress info logging')
   .action(async (options) => {
-    await envLoad({ config: options.config })
+    await envLoad({ config: options.config, quiet: options.quiet })
   })
 
 program
   .command('env-clear')
-  .description('Clear previously loaded environment variables. Usage: source <(infra-kit env-clear)')
+  .description('Clear previously loaded environment variables. Usage: env-clear (after shell init)')
   .action(async () => {
     await envClear()
   })

package/src/entry/mcp.ts

@@ -1,16 +1,11 @@
-/* eslint-disable antfu/no-top-level-await */
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import process from 'node:process'
 
 import { setupErrorHandlers } from 'src/lib/error-handlers'
-import { loadEnvFromGitRoot } from 'src/lib/load-env'
 import { initLoggerMcp } from 'src/lib/logger'
 
 import { createMcpServer } from '../mcp/server'
 
-// Load .env before anything else
-await loadEnvFromGitRoot()
-
 const logger = initLoggerMcp()
 
 const startServer = async () => {

package/src/lib/constants.ts

@@ -1,3 +1,7 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+
 /**
  * List of environments for the project deployment
  */
@@ -9,16 +13,33 @@ export const DOPPLER_PROJECT_MAP: Record<string, string> = {
 }
 
 export const ENV_CACHE_DIR = './node_modules/.cache/infra-kit'
-export const ENV_CACHE_FILE = 'env-cache.json'
+export const ENV_LOAD_FILE = 'env-load.env'
+export const ENV_CLEAR_FILE = 'env-clear.sh'
 
+export const INFRA_KIT_SESSION_VAR = 'INFRA_KIT_SESSION'
 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'
 
-export interface EnvCache {
-  config: string
-  loadedAt: string
-  varNames: string[]
+export const parseVarNamesFromEnvFile = (filePath: string): string[] => {
+  if (!fs.existsSync(filePath)) return []
+
+  const content = fs.readFileSync(filePath, 'utf-8')
+
+  return content
+    .split('\n')
+    .filter((line) => line.includes('=') && !line.startsWith('set '))
+    .map((line) => line.split('=')[0]!)
+}
+
+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 env-init` first.')
+  }
+
+  return path.join(ENV_CACHE_DIR, session)
 }
 
 export const WORKTREES_DIR_SUFFIX = '-worktrees'

package/src/lib/logger/index.ts

@@ -27,6 +27,7 @@ export const initLoggerCLI = () => {
   const logger = pino(
     { level: logLevel },
     pretty({
+      destination: 2,
       ignore: ignoreFields.join(','),
       colorize: true,
     }),

package/src/lib/load-env/index.ts

@@ -1 +0,0 @@
-export { loadEnvFromGitRoot } from './load-env'

package/src/lib/load-env/load-env.ts

@@ -1,28 +0,0 @@
-import { config } from 'dotenv'
-import { resolve } from 'node:path'
-import { $ } from 'zx'
-
-import { getProjectRoot } from 'src/lib/git-utils'
-import { logger } from 'src/lib/logger'
-
-/**
- * Load .env file from git repository root
- * Uses getProjectRoot to find the repository root, works regardless of where package is installed
- */
-export const loadEnvFromGitRoot = async (): Promise<void> => {
-  try {
-    $.quiet = true
-
-    const gitRoot = await getProjectRoot()
-
-    // TODO: remove this after new env managemement
-    config({ path: resolve(gitRoot, '.env'), quiet: true })
-
-    logger.info('Loaded .env file from git repository root')
-  } catch {
-    // Git command failed - not in a git repository or git not available
-    // This is acceptable, env vars might be provided another way
-  } finally {
-    $.quiet = false
-  }
-}