infra-kit 0.1.72 → 0.1.75

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infra-kit",
   "type": "module",
-  "version": "0.1.72",
+  "version": "0.1.75",
   "description": "infra-kit",
   "main": "dist/cli.js",
   "module": "dist/cli.js",
@@ -30,9 +30,9 @@
     "fix": "pnpm run prettier-fix && pnpm run eslint-fix && pnpm run qa"
   },
   "dependencies": {
-    "@inquirer/checkbox": "^5.1.0",
-    "@inquirer/confirm": "^6.0.8",
-    "@inquirer/select": "^5.1.0",
+    "@inquirer/checkbox": "^5.1.2",
+    "@inquirer/confirm": "^6.0.10",
+    "@inquirer/select": "^5.1.2",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
@@ -45,7 +45,7 @@
   "devDependencies": {
     "@pkg/eslint-config": "workspace:*",
     "@pkg/vitest-config": "workspace:*",
-    "esbuild": "^0.27.3",
+    "esbuild": "^0.27.4",
     "typescript": "^5.9.3"
   }
 }

package/src/commands/doctor/doctor.ts

@@ -0,0 +1,105 @@
+import { z } from 'zod'
+import { $ } from 'zx'
+
+import { logger } from 'src/lib/logger'
+import type { ToolsExecutionResult } from 'src/types'
+
+interface CheckResult {
+  name: string
+  status: 'pass' | 'fail'
+  message: string
+}
+
+const checkCommand = async (
+  name: string,
+  command: string[],
+  successMsg: string,
+  failMsg: string,
+): Promise<CheckResult> => {
+  try {
+    await $`${command}`
+
+    return { name, status: 'pass', message: successMsg }
+  } catch {
+    return { name, status: 'fail', message: failMsg }
+  }
+}
+
+/**
+ * Check installation and authentication status of gh and doppler CLIs
+ */
+export const doctor = async (): Promise<ToolsExecutionResult> => {
+  const checks: CheckResult[] = await Promise.all([
+    checkCommand(
+      'gh installed',
+      ['gh', '--version'],
+      'GitHub CLI is installed',
+      'GitHub CLI is not installed. Install from: https://cli.github.com/',
+    ),
+    checkCommand(
+      'gh authenticated',
+      ['gh', 'auth', 'status'],
+      'GitHub CLI is authenticated',
+      'GitHub CLI is not authenticated. Run: gh auth login',
+    ),
+    checkCommand(
+      'doppler installed',
+      ['doppler', '--version'],
+      'Doppler CLI is installed',
+      'Doppler CLI is not installed. Install from: https://docs.doppler.com/docs/install-cli',
+    ),
+    checkCommand(
+      'doppler authenticated',
+      ['doppler', 'me'],
+      'Doppler CLI is authenticated',
+      'Doppler CLI is not authenticated. Run: doppler login',
+    ),
+  ])
+
+  logger.info('Doctor check results:\n')
+
+  for (const check of checks) {
+    const icon = check.status === 'pass' ? '[PASS]' : '[FAIL]'
+
+    logger.info(`  ${icon} ${check.name}: ${check.message}`)
+  }
+
+  const structuredContent = {
+    checks: checks.map((c) => {
+      return { name: c.name, status: c.status, message: c.message }
+    }),
+    allPassed: checks.every((c) => {
+      return c.status === 'pass'
+    }),
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(structuredContent, null, 2),
+      },
+    ],
+    structuredContent,
+  }
+}
+
+// MCP Tool Registration
+export const doctorMcpTool = {
+  name: 'doctor',
+  description: 'Check installation and authentication status of gh and doppler CLIs',
+  inputSchema: {},
+  outputSchema: {
+    checks: z
+      .array(
+        z.object({
+          name: z.string().describe('Name of the check'),
+          status: z.enum(['pass', 'fail']).describe('Check result'),
+          message: z.string().describe('Details about the check result'),
+        }),
+      )
+      .describe('List of all check results'),
+    allPassed: z.boolean().describe('Whether all checks passed'),
+  },
+  handler: doctor,
+}

package/src/commands/doctor/index.ts

@@ -0,0 +1 @@
+export { doctor, doctorMcpTool } from './doctor'

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

@@ -0,0 +1,91 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import { z } from 'zod'
+
+import {
+  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: env-clear (after running eval "$(infra-kit env-init)" in shell)
+ */
+export const envClear = async (): Promise<ToolsExecutionResult> => {
+  const cacheDir = getSessionCacheDir()
+  const envLoadPath = path.join(cacheDir, ENV_LOAD_FILE)
+
+  if (!fs.existsSync(envLoadPath)) {
+    logger.error('No loaded environment found. Run `env-load` first.')
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'No loaded environment found. Run `env-load` first.',
+        },
+      ],
+    }
+  }
+
+  const varNames = parseVarNamesFromEnvFile(envLoadPath)
+
+  // 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}`,
+  ]
+
+  // Write unset script to cache
+  const clearFilePath = path.resolve(cacheDir, ENV_CLEAR_FILE)
+
+  fs.mkdirSync(cacheDir, { recursive: true })
+  fs.writeFileSync(clearFilePath, `${unsetLines.join('\n')}\n`)
+
+  // REQUIRED
+  process.stdout.write(`${clearFilePath}\n`)
+
+  // Remove env load file so env-clear can detect "no env loaded" next time
+  fs.unlinkSync(envLoadPath)
+
+  logger.info(`Cleared ${varNames.length} environment variables`)
+
+  const structuredContent = {
+    variableCount: varNames.length,
+    unsetStatements: unsetLines,
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(structuredContent, null, 2),
+      },
+    ],
+    structuredContent,
+  }
+}
+
+// MCP Tool Registration
+export const envClearMcpTool = {
+  name: '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'),
+    unsetStatements: z.array(z.string()).describe('Unset statements generated'),
+  },
+  handler: envClear,
+}

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

@@ -0,0 +1 @@
+export { envClear, envClearMcpTool } from './env-clear'

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-list/env-list.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod'
+
+import { validateDopplerCliAndAuth } from 'src/integrations/doppler'
+import { getDopplerProject } from 'src/integrations/doppler/doppler-project'
+import { ENVs } from 'src/lib/constants'
+import { logger } from 'src/lib/logger'
+import type { ToolsExecutionResult } from 'src/types'
+
+/**
+ * List available Doppler configs for the detected project
+ */
+export const envList = async (): Promise<ToolsExecutionResult> => {
+  await validateDopplerCliAndAuth()
+
+  const project = await getDopplerProject()
+
+  logger.info(`Doppler Project: ${project}\n`)
+  logger.info('Available Configs:')
+
+  for (const env of ENVs) {
+    logger.info(`  - ${env}`)
+  }
+
+  const structuredContent = {
+    project,
+    configs: ENVs,
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(structuredContent, null, 2),
+      },
+    ],
+    structuredContent,
+  }
+}
+
+// MCP Tool Registration
+export const envListMcpTool = {
+  name: 'env-list',
+  description: 'List available Doppler configs for the detected project',
+  inputSchema: {},
+  outputSchema: {
+    project: z.string().describe('Detected Doppler project name'),
+    configs: z.array(z.string()).describe('Available environment configs'),
+  },
+  handler: envList,
+}

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

@@ -0,0 +1 @@
+export { envList, envListMcpTool } from './env-list'

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

@@ -0,0 +1,120 @@
+import select from '@inquirer/select'
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import { z } from 'zod'
+import { $ } from 'zx'
+
+import { validateDopplerCliAndAuth } from 'src/integrations/doppler'
+import { getDopplerProject } from 'src/integrations/doppler/doppler-project'
+import { commandEcho } from 'src/lib/command-echo'
+import {
+  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
+  quiet?: boolean
+}
+
+/**
+ * Load environment variables from Doppler for the given config
+ */
+export const envLoad = async (args: EnvLoadArgs): Promise<ToolsExecutionResult> => {
+  await validateDopplerCliAndAuth()
+
+  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()
+
+  $.quiet = true
+  const result =
+    await $`doppler secrets download --no-file --format env --project ${project} --config ${selectedConfig}`
+
+  $.quiet = false
+  const envContent = result.stdout.trim()
+
+  // 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',
+  ]
+
+  // Write env file to cache
+  const cacheDir = getSessionCacheDir()
+  const envFilePath = path.resolve(cacheDir, ENV_LOAD_FILE)
+
+  fs.mkdirSync(cacheDir, { recursive: true })
+  fs.writeFileSync(envFilePath, `${envFileLines.join('\n')}\n`)
+
+  // REQUIRED
+  process.stdout.write(`${envFilePath}\n`)
+
+  const varCount = envContent.split('\n').filter((line) => line.includes('=')).length
+
+  if (!quiet) {
+    logger.info(`Loaded ${varCount} variables from ${project}/${selectedConfig}`)
+  }
+
+  const structuredContent = {
+    variableCount: varCount,
+    project,
+    config: selectedConfig,
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(structuredContent, null, 2),
+      },
+    ],
+    structuredContent,
+  }
+}
+
+// MCP Tool Registration
+export const envLoadMcpTool = {
+  name: 'env-load',
+  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)'),
+  },
+  outputSchema: {
+    variableCount: z.number().describe('Number of variables loaded'),
+    project: z.string().describe('Doppler project name'),
+    config: z.string().describe('Doppler config name'),
+  },
+  handler: envLoad,
+}

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

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

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

@@ -0,0 +1,103 @@
+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 {
+  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'
+
+/**
+ * Show Doppler authentication status and detected project info
+ */
+export const envStatus = async (): Promise<ToolsExecutionResult> => {
+  await validateDopplerCliAndAuth()
+
+  const project = await getDopplerProject()
+
+  logger.info('Doppler Environment Status:\n')
+  logger.info(`  Authenticated: yes`)
+  logger.info(`  Detected Project: ${project}`)
+  logger.info(`  Available Configs: ${ENVs.join(', ')}`)
+
+  // 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
+  const sessionConfig = process.env[INFRA_KIT_ENV_CONFIG_VAR] ?? null
+  const sessionProject = process.env[INFRA_KIT_ENV_PROJECT_VAR] ?? null
+  const sessionLoadedAt = process.env[INFRA_KIT_ENV_LOADED_AT_VAR] ?? null
+
+  if (sessionConfig) {
+    const varNames = parseVarNamesFromEnvFile(envLoadPath)
+
+    if (varNames.length > 0) {
+      sessionTotalCount = varNames.length
+      sessionLoadedCount = varNames.filter((v) => {
+        return v in process.env
+      }).length
+    }
+
+    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')
+  }
+
+  const structuredContent = {
+    authenticated: true,
+    project,
+    configs: ENVs,
+    sessionId,
+    sessionLoadedCount,
+    sessionTotalCount,
+    sessionConfig,
+    sessionProject,
+    sessionLoadedAt,
+  }
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(structuredContent, null, 2),
+      },
+    ],
+    structuredContent,
+  }
+}
+
+// MCP Tool Registration
+export const envStatusMcpTool = {
+  name: 'env-status',
+  description: 'Show Doppler authentication status and detected project info',
+  inputSchema: {},
+  outputSchema: {
+    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'),
+    sessionProject: z.string().nullable().describe('Doppler project name of the loaded session'),
+    sessionLoadedAt: z.string().nullable().describe('ISO 8601 timestamp of when the env was loaded'),
+  },
+  handler: envStatus,
+}

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

@@ -0,0 +1 @@
+export { envStatus, envStatusMcpTool } from './env-status'

package/src/entry/cli.ts

@@ -1,5 +1,11 @@
 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'
 // Commands
 import { ghMergeDev } from 'src/commands/gh-merge-dev'
 import { ghReleaseDeliver } from 'src/commands/gh-release-deliver'
@@ -13,12 +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'
-// Integrations
-import { validateGitHubCliAndAuth } from 'src/integrations/gh'
-import { loadEnvFromGitRoot } from 'src/lib/load-env'
-
-// Load .env before anything else
-await loadEnvFromGitRoot()
 
 const program = new Command()
 
@@ -153,6 +153,48 @@ program
     await worktreesRemove({ confirmedCommand: options.yes, all: options.all })
   })
 
-await validateGitHubCliAndAuth()
+program
+  .command('doctor')
+  .description('Check installation and authentication status of gh and doppler CLIs')
+  .action(async () => {
+    await doctor()
+  })
+
+program
+  .command('env-status')
+  .description('Show Doppler authentication status and detected project info')
+  .action(async () => {
+    await envStatus()
+  })
+
+program
+  .command('env-list')
+  .description('List available Doppler configs for the detected project')
+  .action(async () => {
+    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: 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, quiet: options.quiet })
+  })
+
+program
+  .command('env-clear')
+  .description('Clear previously loaded environment variables. Usage: env-clear (after shell init)')
+  .action(async () => {
+    await envClear()
+  })
 
 program.parse()

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 () => {