infra-kit 0.1.72 → 0.1.74

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infra-kit",
   "type": "module",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "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,99 @@
+import fs from 'node:fs'
+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,
+  INFRA_KIT_ENV_CONFIG_VAR,
+  INFRA_KIT_ENV_LOADED_AT_VAR,
+  INFRA_KIT_ENV_PROJECT_VAR,
+} 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)
+ */
+export const envClear = async (): Promise<ToolsExecutionResult> => {
+  const cachePath = path.join(ENV_CACHE_DIR, ENV_CACHE_FILE)
+
+  if (!process.env[INFRA_KIT_ENV_CONFIG_VAR]) {
+    logger.error('No loaded environment found. Run `env-load` first.')
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'No loaded environment found. Run `env-load` first.',
+        },
+      ],
+    }
+  }
+
+  const cache: EnvCache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'))
+  const varNames = cache.varNames
+
+  // Only unset vars that are actually set in the current session
+  const activeVars = varNames.filter((v) => {
+    return v in process.env
+  })
+
+  if (activeVars.length === 0) {
+    fs.unlinkSync(cachePath)
+    logger.info('Current session is clear, no environment variables to unset.')
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Current session is clear, no environment variables to unset.',
+        },
+      ],
+    }
+  }
+
+  // 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`)
+
+  // Remove cache file
+  fs.unlinkSync(cachePath)
+
+  logger.info(`Cleared ${activeVars.length} environment variables`)
+
+  const structuredContent = {
+    variableCount: activeVars.length,
+    unsetStatements: activeVars.map((v) => {
+      return `unset ${v}`
+    }),
+  }
+
+  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: source <(infra-kit env-clear)',
+  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-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,94 @@
+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 type { EnvCache } from 'src/lib/constants'
+import {
+  ENV_CACHE_DIR,
+  ENV_CACHE_FILE,
+  INFRA_KIT_ENV_CONFIG_VAR,
+  INFRA_KIT_ENV_LOADED_AT_VAR,
+  INFRA_KIT_ENV_PROJECT_VAR,
+} from 'src/lib/constants'
+import { logger } from 'src/lib/logger'
+import type { ToolsExecutionResult } from 'src/types'
+
+interface EnvLoadArgs {
+  config: string
+}
+
+/**
+ * Load environment variables from Doppler for the given config
+ */
+export const envLoad = async (args: EnvLoadArgs): Promise<ToolsExecutionResult> => {
+  await validateDopplerCliAndAuth()
+
+  const { config } = args
+
+  const project = await getDopplerProject()
+
+  const result = await $`doppler secrets download --no-file --format env --project ${project} --config ${config}`
+  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]!
+    })
+
+  const cachePath = path.join(ENV_CACHE_DIR, ENV_CACHE_FILE)
+
+  const cache: EnvCache = { config, loadedAt: new Date().toISOString(), varNames }
+
+  fs.mkdirSync(ENV_CACHE_DIR, { recursive: true })
+  fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2))
+
+  logger.info(`Loaded ${varNames.length} variables from ${project}/${config}`)
+
+  const structuredContent = {
+    variableCount: varNames.length,
+    project,
+    config,
+  }
+
+  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: source <(infra-kit env-load -c dev)',
+  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,97 @@
+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,
+  ENVs,
+  INFRA_KIT_ENV_CONFIG_VAR,
+  INFRA_KIT_ENV_LOADED_AT_VAR,
+  INFRA_KIT_ENV_PROJECT_VAR,
+} 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
+  const cachePath = path.join(ENV_CACHE_DIR, ENV_CACHE_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) {
+    if (fs.existsSync(cachePath)) {
+      const cache: EnvCache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'))
+
+      sessionTotalCount = cache.varNames.length
+      sessionLoadedCount = cache.varNames.filter((v) => {
+        return v in process.env
+      }).length
+    }
+
+    logger.info(
+      `  Session: ${sessionLoadedCount} of ${sessionTotalCount} vars loaded (project: ${sessionProject}, config: ${sessionConfig}, loaded at: ${sessionLoadedAt})`,
+    )
+  } else {
+    logger.info('  Session: no env loaded')
+  }
+
+  const structuredContent = {
+    authenticated: true,
+    project,
+    configs: ENVs,
+    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'),
+    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,10 @@
 import { Command } from 'commander'
 
+import { doctor } from 'src/commands/doctor'
+import { envClear } from 'src/commands/env-clear'
+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,8 +18,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
@@ -153,6 +156,40 @@ 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-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)')
+  .action(async (options) => {
+    await envLoad({ config: options.config })
+  })
+
+program
+  .command('env-clear')
+  .description('Clear previously loaded environment variables. Usage: source <(infra-kit env-clear)')
+  .action(async () => {
+    await envClear()
+  })
 
 program.parse()

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

@@ -0,0 +1,25 @@
+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
+ */
+export const validateDopplerCliAndAuth = async () => {
+  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)
+  }
+
+  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)
+  }
+}

package/src/integrations/doppler/doppler-project.ts

@@ -0,0 +1,23 @@
+import path from 'node:path'
+
+import { DOPPLER_PROJECT_MAP } from 'src/lib/constants'
+import { getProjectRoot } from 'src/lib/git-utils'
+
+/**
+ * Resolve Doppler project name from the current working directory
+ */
+export const getDopplerProject = async (): Promise<string> => {
+  const projectRoot = await getProjectRoot()
+
+  const dirName = path.basename(projectRoot)
+  const dopplerProject = DOPPLER_PROJECT_MAP[dirName]
+
+  if (!dopplerProject) {
+    throw new Error(
+      `Could not determine Doppler project for directory "${dirName}". ` +
+        `Expected one of: ${Object.keys(DOPPLER_PROJECT_MAP).join(', ')}`,
+    )
+  }
+
+  return dopplerProject
+}

package/src/integrations/doppler/index.ts

@@ -0,0 +1,2 @@
+export { validateDopplerCliAndAuth } from './doppler-cli-auth'
+export { getDopplerProject } from './doppler-project'

package/src/lib/constants.ts

@@ -3,6 +3,24 @@
  */
 export const ENVs = ['dev', 'arthur', 'renana', 'roman', 'eliran', 'oriana']
 
+export const DOPPLER_PROJECT_MAP: Record<string, string> = {
+  'hulyo-monorepo': 'hulyo',
+  'travelist-monorepo': 'travelist',
+}
+
+export const ENV_CACHE_DIR = './node_modules/.cache/infra-kit'
+export const ENV_CACHE_FILE = 'env-cache.json'
+
+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 WORKTREES_DIR_SUFFIX = '-worktrees'
 // eslint-disable-next-line sonarjs/publicly-writable-directories
 export const LOG_FILE_PATH = '/tmp/mcp-infra-kit.log'

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

@@ -15,6 +15,7 @@ export const loadEnvFromGitRoot = async (): Promise<void> => {
 
     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')

package/src/mcp/tools/index.ts

@@ -1,5 +1,9 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 
+import { envClearMcpTool } from 'src/commands/env-clear'
+import { envListMcpTool } from 'src/commands/env-list'
+import { envLoadMcpTool } from 'src/commands/env-load'
+import { envStatusMcpTool } from 'src/commands/env-status'
 import { ghMergeDevMcpTool } from 'src/commands/gh-merge-dev'
 import { ghReleaseDeliverMcpTool } from 'src/commands/gh-release-deliver'
 import { ghReleaseDeployAllMcpTool } from 'src/commands/gh-release-deploy-all'
@@ -15,6 +19,10 @@ import { worktreesSyncMcpTool } from 'src/commands/worktrees-sync'
 import { createToolHandler } from 'src/lib/tool-handler'
 
 const tools = [
+  envStatusMcpTool,
+  envListMcpTool,
+  envLoadMcpTool,
+  envClearMcpTool,
   ghMergeDevMcpTool,
   releaseCreateMcpTool,
   releaseCreateBatchMcpTool,