@lkangd/cc-env 1.0.0

package/src/commands/preset/show.ts

@@ -0,0 +1,51 @@
+import type { EnvMap } from '../../core/schema.js'
+
+type PresetService = {
+  listNames: () => Promise<string[]>
+  read: (name: string) => Promise<{ env: EnvMap }>
+}
+
+type ProjectEnvService = {
+  readWithMeta: () => Promise<{ env: EnvMap; name?: string | undefined }>
+}
+
+export type PresetSource = 'global' | 'project'
+
+export type PresetShowItem = {
+  name: string
+  env: EnvMap
+  source: PresetSource
+}
+
+export function createShowPresetsCommand({
+  presetService,
+  projectEnvService,
+  renderShow,
+}: {
+  presetService: PresetService
+  projectEnvService: ProjectEnvService
+  renderShow: (presets: Array<PresetShowItem>) => Promise<void>
+}) {
+  return async function showPresets(): Promise<void> {
+    const names = await presetService.listNames()
+    const globalPresets = await Promise.all(
+      names.map((name) =>
+        presetService.read(name).then((p) => ({ name, env: p.env, source: 'global' as const })),
+      ),
+    )
+
+    const { env: projectEnv, name: projectName } = await projectEnvService.readWithMeta()
+    const projectPreset =
+      Object.keys(projectEnv).length > 0
+        ? [{ name: projectName ?? 'project', env: projectEnv, source: 'project' as const }]
+        : []
+
+    const presets = [...projectPreset, ...globalPresets]
+    if (presets.length === 0) {
+      console.log('No presets found.')
+      return
+    }
+
+    await renderShow(presets)
+  }
+}

package/src/commands/restore.ts

@@ -0,0 +1,150 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+
+import { CliError } from '../core/errors.js'
+import type { EnvMap, HistoryRecord, Preset } from '../core/schema.js'
+import type { ClaudeSettingsSource } from '../services/claude-settings-env-service.js'
+import type { ShellWriteRecord } from '../services/shell-env-service.js'
+
+const h = React.createElement
+
+type HistoryService = {
+  list: () => Promise<HistoryRecord[]>
+}
+
+type ClaudeSettingsEnvService = {
+  read: () => Promise<ClaudeSettingsSource[]>
+  write: (sources: Array<{ path: string; env: EnvMap }>) => Promise<void>
+}
+
+type ShellEnvService = {
+  removeKeys: (shellWrites: ShellWriteRecord[], keys: string[]) => Promise<void>
+}
+
+type SettingsEnvService = {
+  read: () => Promise<EnvMap>
+  write: (env: EnvMap) => Promise<unknown>
+}
+
+type PresetService = {
+  read: (name: string) => Promise<Preset>
+  write: (preset: Preset) => Promise<unknown>
+}
+
+type RestoreFlowResult = {
+  confirmed?: boolean
+  timestamp?: string
+  targetType?: 'settings' | 'preset'
+  targetName?: string
+}
+
+export function createRestoreCommand({
+  historyService,
+  claudeSettingsEnvService,
+  shellEnvService,
+  settingsEnvService,
+  presetService,
+  renderFlow,
+  renderEnvSummary,
+}: {
+  historyService: HistoryService
+  claudeSettingsEnvService: ClaudeSettingsEnvService
+  shellEnvService: ShellEnvService
+  settingsEnvService: SettingsEnvService
+  presetService: PresetService
+  renderFlow: (context: {
+    records: HistoryRecord[]
+    yes: boolean
+  }) => Promise<RestoreFlowResult | void> | RestoreFlowResult | void
+  renderEnvSummary: (props: {
+    title: string
+    env: EnvMap
+    fromFiles?: string[]
+    toFiles?: string[]
+    footer?: React.ReactNode
+  }) => Promise<void>
+}) {
+  return async function restore({ yes = false }: { yes?: boolean } = {}): Promise<void> {
+    const records = await historyService.list()
+    const result = await renderFlow({ records, yes })
+
+    if (!result?.confirmed) {
+      return
+    }
+
+    const record = records.find((entry) => entry.timestamp === result.timestamp)
+
+    if (!record) {
+      throw new CliError('Restore record not found')
+    }
+
+    if (record.action === 'init') {
+      const mergedBackup = Object.fromEntries(
+        record.sources.flatMap((s) => Object.entries(s.backup)),
+      )
+
+      const current = await claudeSettingsEnvService.read()
+      await shellEnvService.removeKeys(record.shellWrites, record.migratedKeys)
+      await claudeSettingsEnvService.write(
+        current.map((source) => ({
+          path: source.path,
+          env: {
+            ...source.env,
+            ...(record.sources.find((s) => s.file === source.path)?.backup ?? {}),
+          },
+        })),
+      )
+
+      await renderEnvSummary({
+        title: 'Restored',
+        env: mergedBackup,
+        fromFiles: record.shellWrites.map((sw) => sw.filePath),
+        toFiles: record.sources.map((s) => s.file),
+        footer: h(Box, { flexDirection: 'column' },
+          h(Text, { color: 'green' }, 'Restore complete'),
+          h(Text, { bold: true, color: 'green' }, 'Please restart your terminal for the restored environment variables to take effect.'),
+        ),
+      })
+      return
+    }
+
+    if (result.targetType === 'settings') {
+      const currentSettings = await settingsEnvService.read()
+      await settingsEnvService.write({
+        ...currentSettings,
+        ...record.backup,
+      })
+
+      await renderEnvSummary({
+        title: 'Restored to settings',
+        env: record.backup,
+        footer: h(Box, { flexDirection: 'column' },
+          h(Text, { color: 'green' }, 'Restore complete'),
+          h(Text, { bold: true, color: 'green' }, 'Please restart your terminal for the restored environment variables to take effect.'),
+        ),
+      })
+      return
+    }
+
+    const presetName = result.targetName ?? record.targetName
+    const preset = await presetService.read(presetName)
+
+    await presetService.write({
+      ...preset,
+      updatedAt: new Date().toISOString(),
+      env: {
+        ...preset.env,
+        ...record.backup,
+      },
+    })
+
+    await renderEnvSummary({
+      title: `Restored to preset ${presetName}`,
+      env: record.backup,
+      footer: h(Box, { flexDirection: 'column' },
+        h(Text, { color: 'green' }, 'Restore complete'),
+        h(Text, { bold: true, color: 'green' }, 'Please restart your terminal for the restored environment variables to take effect.'),
+      ),
+    })
+  }
+}

package/src/commands/run.ts

@@ -0,0 +1,158 @@
+import { CliError } from '../core/errors.js'
+import { formatRunEnvBlock } from '../core/format.js'
+import type { EnvMap } from '../core/schema.js'
+
+const requiredInitKeys = [
+  'ANTHROPIC_AUTH_TOKEN',
+  'ANTHROPIC_BASE_URL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_REASONING_MODEL',
+] as const
+
+type PresetSelectItem = {
+  name: string
+  env: EnvMap
+  source: 'global' | 'project'
+}
+
+type ClaudeSettingsEnvService = {
+  read: () => Promise<Array<{ path: string; exists: boolean; env: EnvMap }>>
+}
+
+type PresetService = {
+  listNames: () => Promise<string[]>
+  read: (name: string) => Promise<{ env: EnvMap }>
+}
+
+type ProjectEnvService = {
+  readWithMeta: () => Promise<{ env: EnvMap; name?: string | undefined }>
+}
+
+type ProjectStateService = {
+  getLastPreset: (cwd: string) => Promise<{ presetName: string; source: 'global' | 'project' } | undefined>
+  saveLastPreset: (cwd: string, ref: { presetName: string; source: 'global' | 'project' }) => Promise<void>
+}
+
+type FindClaude = () => string
+
+type RenderPresetSelect = (input: {
+  presets: Array<PresetSelectItem>
+  defaultIndex: number
+}) => Promise<PresetSelectItem | undefined>
+
+export function createRunCommand({
+  claudeSettingsEnvService,
+  presetService,
+  projectEnvService,
+  projectStateService,
+  findClaude,
+  renderPresetSelect,
+  spawnCommand,
+  stdout = process.stdout,
+}: {
+  claudeSettingsEnvService: ClaudeSettingsEnvService
+  presetService: PresetService
+  projectEnvService: ProjectEnvService
+  projectStateService: ProjectStateService
+  findClaude: FindClaude
+  renderPresetSelect: RenderPresetSelect
+  spawnCommand: (command: string, args: string[], env: NodeJS.ProcessEnv) => Promise<void>
+  stdout?: Pick<NodeJS.WriteStream, 'write'>
+}) {
+  return async function run({
+    args = [],
+    dryRun = false,
+    yes = false,
+    cwd,
+  }: {
+    args?: string[]
+    dryRun?: boolean
+    yes?: boolean
+    cwd: string
+  }): Promise<void> {
+    // Step 0: Check settings files for init-managed keys
+    const sources = await claudeSettingsEnvService.read()
+    const mergedSettingsEnv = sources.reduce<EnvMap>(
+      (acc, s) => ({ ...acc, ...s.env }),
+      {} as EnvMap,
+    )
+    const staleKeys = requiredInitKeys.filter((k) => k in mergedSettingsEnv)
+    if (staleKeys.length > 0) {
+      throw new CliError(
+        `Found init-managed keys in Claude settings:\n\n  ${staleKeys.join(', \n  ')}. \n\n  Run "cc-env init" first.`,
+      )
+    }
+
+    // Step 1: Collect all presets (project + global)
+    const names = await presetService.listNames()
+    const globalPresets = await Promise.all(
+      names.map((name) =>
+        presetService.read(name).then((p) => ({ name, env: p.env, source: 'global' as const })),
+      ),
+    )
+    const { env: projectEnv, name: projectName } = await projectEnvService.readWithMeta()
+    const projectPreset =
+      Object.keys(projectEnv).length > 0
+        ? [{ name: projectName ?? 'project', env: projectEnv, source: 'project' as const }]
+        : []
+
+    const presets = [...projectPreset, ...globalPresets]
+    if (presets.length === 0) {
+      throw new CliError('No presets found. Create one with "cc-env preset create".')
+    }
+
+    // Step 2: Determine default selection
+    const savedRef = await projectStateService.getLastPreset(cwd)
+    let defaultIndex = 0
+    if (savedRef) {
+      const idx = presets.findIndex(
+        (p) => p.name === savedRef.presetName && p.source === savedRef.source,
+      )
+      if (idx >= 0) defaultIndex = idx
+    } else if (projectPreset.length > 0) {
+      defaultIndex = 0
+    }
+
+    // Step 3: Select preset (interactive or auto)
+    let selected: PresetSelectItem | undefined
+    if (yes) {
+      selected = presets[defaultIndex]
+    } else {
+      selected = await renderPresetSelect({ presets, defaultIndex })
+    }
+    if (!selected) return
+
+    // Step 4: Save selection
+    await projectStateService.saveLastPreset(cwd, {
+      presetName: selected.name,
+      source: selected.source,
+    })
+
+    // Step 5: Resolve claude command
+    let command: string
+    let claudeArgs: string[]
+    if (args.length > 0 && args[0] === 'claude') {
+      command = 'claude'
+      claudeArgs = args.slice(1)
+    } else {
+      command = findClaude()
+      claudeArgs = args
+    }
+
+    // Step 6: Print env vars
+    const presetKeys = new Set(Object.keys(selected.env))
+    const envBlock = formatRunEnvBlock(selected.env, presetKeys)
+    stdout.write(`Using preset: ${selected.name} (${selected.source})\n${envBlock}\n\n`)
+
+    if (dryRun) {
+      const preview = [command, ...claudeArgs].join(' ')
+      stdout.write(`Would run: ${preview}\n`)
+      return
+    }
+
+    // Step 7: Spawn
+    await spawnCommand(command, claudeArgs, { ...process.env, ...selected.env })
+  }
+}

package/src/core/errors.ts

@@ -0,0 +1,13 @@
+export class CliError extends Error {
+  readonly exitCode: number
+
+  constructor(message: string, exitCode = 1) {
+    super(message)
+    this.name = 'CliError'
+    this.exitCode = exitCode
+  }
+}
+
+export function invalidUsage(message: string): CliError {
+  return new CliError(message, 2)
+}

package/src/core/find-claude.ts

@@ -0,0 +1,70 @@
+import { execSync } from 'node:child_process'
+import { existsSync, readFileSync, realpathSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { CliError } from './errors.js'
+
+function resolveToJsFile(filePath: string): string {
+  try {
+    const realPath = realpathSync(filePath)
+    if (realPath.endsWith('.js')) return realPath
+    if (existsSync(realPath)) {
+      const content = readFileSync(realPath, 'utf-8')
+      if (
+        content.startsWith('#!/usr/bin/env node') ||
+        /^#!.*\/node$/m.test(content) ||
+        content.includes('require(') ||
+        content.includes('import ')
+      ) {
+        return realPath
+      }
+    }
+
+    for (const candidate of [
+      realPath + '.js',
+      realPath.replace(/\/bin\//, '/lib/') + '.js',
+      realPath.replace(/\/\.bin\//, '/lib/bin/') + '.js',
+    ]) {
+      if (existsSync(candidate)) return candidate
+    }
+
+    return realPath
+  } catch {
+    return filePath
+  }
+}
+
+export function findClaudeExecutable(): string {
+  try {
+    let claudePath = execSync('which claude', { encoding: 'utf-8' }).trim()
+    const aliasMatch = claudePath.match(/:\s*aliased to\s+(.+)$/)
+    if (aliasMatch?.[1]) claudePath = aliasMatch[1]
+
+    if (existsSync(claudePath)) {
+      const content = readFileSync(claudePath, 'utf-8')
+      if (content.startsWith('#!/bin/bash')) {
+        const execMatch = content.match(/exec\s+"([^"]+)"/)
+        if (execMatch?.[1]) return resolveToJsFile(execMatch[1])
+      }
+    }
+
+    return resolveToJsFile(claudePath)
+  } catch {}
+
+  const home = process.env.HOME ?? process.cwd()
+  const localWrapper = join(home, '.claude', 'local', 'claude')
+  if (existsSync(localWrapper)) {
+    const content = readFileSync(localWrapper, 'utf-8')
+    if (content.startsWith('#!/bin/bash')) {
+      const execMatch = content.match(/exec\s+"([^"]+)"/)
+      if (execMatch?.[1]) return resolveToJsFile(execMatch[1])
+    }
+  }
+
+  const localBin = join(home, '.claude', 'local', 'node_modules', '.bin', 'claude')
+  if (existsSync(localBin)) return resolveToJsFile(localBin)
+
+  throw new CliError(
+    'Claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code',
+  )
+}

package/src/core/format.ts

@@ -0,0 +1,29 @@
+import { maskValue } from './mask.js'
+import type { EnvMap } from './schema.js'
+
+export function formatEnvBlock(env: EnvMap): string {
+  return Object.entries(env)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${key}=${maskValue(key, value)}`)
+    .join('\n')
+}
+
+export function formatRunEnvBlock(env: EnvMap, presetKeys: ReadonlySet<string>): string {
+  const entries = Object.entries(env).sort(([a], [b]) => a.localeCompare(b))
+  const presetEntries = entries.filter(([key]) => presetKeys.has(key))
+  const otherCount = entries.length - presetEntries.length
+
+  const lines = presetEntries.map(([key, value]) => `${key}=${maskValue(key, value)}`)
+  if (otherCount > 0) {
+    lines.push(`+${otherCount} other env vars applied`)
+  }
+
+  return lines.join('\n')
+}
+
+export function formatRestorePreview(env: EnvMap): string {
+  return Object.entries(env)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${key}=${value}`)
+    .join('\n')
+}

package/src/core/fs.ts

@@ -0,0 +1,18 @@
+import { mkdir, rename, writeFile } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+
+export async function ensureParentDir(filePath: string): Promise<void> {
+  await mkdir(dirname(filePath), { recursive: true })
+}
+
+export async function atomicWriteFile(filePath: string, content: string): Promise<void> {
+  const parentDir = dirname(filePath)
+  const tempFilePath = join(
+    parentDir,
+    `.${basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`,
+  )
+
+  await ensureParentDir(filePath)
+  await writeFile(tempFilePath, content, 'utf8')
+  await rename(tempFilePath, filePath)
+}

package/src/core/gitignore.ts

@@ -0,0 +1,26 @@
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+export function isGitRepo(dir: string): boolean {
+  return existsSync(join(dir, '.git'))
+}
+
+export async function ensureGitignoreEntry(dir: string, entry: string): Promise<void> {
+  if (!isGitRepo(dir)) return
+
+  const gitignorePath = join(dir, '.gitignore')
+  let content = ''
+
+  try {
+    content = await readFile(gitignorePath, 'utf8')
+  } catch {
+    // .gitignore doesn't exist — will create it
+  }
+
+  const lines = content.split('\n')
+  if (lines.some((line) => line === entry || line === `${entry}/`)) return
+
+  const separator = content.length > 0 && !content.endsWith('\n') ? '\n' : ''
+  await writeFile(gitignorePath, `${content}${separator}${entry}\n`, 'utf8')
+}

package/src/core/logger.ts

@@ -0,0 +1,11 @@
+import pino from 'pino'
+
+import { ensureParentDir } from './fs.js'
+import { resolveLogPath } from './paths.js'
+
+export async function createLogger(globalRoot: string) {
+  const logPath = resolveLogPath(globalRoot)
+  await ensureParentDir(logPath)
+
+  return pino(pino.destination(logPath))
+}

package/src/core/mask.ts

@@ -0,0 +1,17 @@
+const sensitiveKeyPattern = /(_TOKEN|_KEY|_SECRET|_PASSWORD)$/i
+
+export function isSensitiveKey(key: string): boolean {
+  return sensitiveKeyPattern.test(key)
+}
+
+export function maskValue(key: string, value: string): string {
+  if (!isSensitiveKey(key)) {
+    return value
+  }
+
+  if (value.length <= 8) {
+    return '*'.repeat(value.length)
+  }
+
+  return `${value.slice(0, 9)}********`
+}

package/src/core/paths.ts

@@ -0,0 +1,41 @@
+import { join } from 'node:path'
+
+export function resolveGlobalRoot(globalRoot?: string): string {
+  return globalRoot ?? join(process.env.HOME ?? process.cwd(), '.cc-env')
+}
+
+export function resolveClaudeSettingsPath(homeDir = process.env.HOME ?? process.cwd()): string {
+  return join(homeDir, '.claude', 'settings.json')
+}
+
+export function resolveClaudeSettingsLocalPath(homeDir = process.env.HOME ?? process.cwd()): string {
+  return join(homeDir, '.claude', 'settings.local.json')
+}
+
+export function resolveProjectSettingsPath(cwd = process.cwd()): string {
+  return join(cwd, '.claude', 'settings.json')
+}
+
+export function resolveProjectSettingsLocalPath(cwd = process.cwd()): string {
+  return join(cwd, '.claude', 'settings.local.json')
+}
+
+export function resolveShellConfigPaths(homeDir = process.env.HOME ?? process.cwd()) {
+  return {
+    zsh: join(homeDir, '.zshrc'),
+    bash: join(homeDir, '.bashrc'),
+    fish: join(homeDir, '.config', 'fish', 'config.fish'),
+  }
+}
+
+export function resolvePresetPath(globalRoot: string, name: string): string {
+  return join(globalRoot, 'presets', `${name}.json`)
+}
+
+export function resolveHistoryPath(globalRoot: string, timestamp: string): string {
+  return join(globalRoot, 'history', `${timestamp.replaceAll(':', '-')}.json`)
+}
+
+export function resolveLogPath(globalRoot: string): string {
+  return join(globalRoot, 'logs', 'app.log')
+}

package/src/core/process-env.ts

@@ -0,0 +1,11 @@
+import { envMapSchema, type EnvMap } from './schema.js'
+
+export function toProcessEnvMap(input: Record<string, unknown>): EnvMap {
+  return envMapSchema.parse(
+    Object.fromEntries(
+      Object.entries(input).filter(
+        ([key, value]) => typeof value === 'string' && /^[A-Z0-9_]+$/.test(key),
+      ),
+    ),
+  )
+}

package/src/core/schema.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod'
+
+const envKeySchema = z.string().regex(/^[A-Z0-9_]+$/)
+
+export const envMapSchema = z.record(
+  envKeySchema,
+  z.unknown()
+    .refine((value) => value === null || typeof value !== 'object')
+    .transform((value) => String(value)),
+)
+
+export const presetSchema = z.object({
+  name: z.string(),
+  createdAt: z.string().datetime({ offset: true }),
+  updatedAt: z.string().datetime({ offset: true }),
+  env: envMapSchema,
+})
+
+const shellWriteSchema = z.object({
+  shell: z.enum(['zsh', 'bash', 'fish']),
+  filePath: z.string(),
+  env: envMapSchema,
+})
+
+const sourceEntrySchema = z.object({
+  file: z.string(),
+  backup: envMapSchema,
+})
+
+const initHistorySchema = z.object({
+  timestamp: z.string().datetime({ offset: true }),
+  action: z.literal('init'),
+  migratedKeys: z.array(envKeySchema),
+  sources: z.array(sourceEntrySchema),
+  shellWrites: z.array(shellWriteSchema),
+})
+
+const restoreHistorySchema = z.object({
+  timestamp: z.string().datetime({ offset: true }),
+  action: z.literal('restore'),
+  backup: envMapSchema,
+  targetType: z.enum(['settings', 'preset']),
+  targetName: z.string(),
+})
+
+export const historySchema = z.discriminatedUnion('action', [
+  initHistorySchema,
+  restoreHistorySchema,
+])
+
+export type EnvMap = z.infer<typeof envMapSchema>
+export type SourceEntry = z.infer<typeof sourceEntrySchema>
+export type Preset = z.infer<typeof presetSchema>
+export type InitHistoryRecord = z.infer<typeof initHistorySchema>
+export type HistoryRecord = z.infer<typeof historySchema>