@lkangd/cc-env 1.1.0 → 1.1.2

package/src/commands/restore.ts

@@ -1,150 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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>

package/src/core/spawn.ts

@@ -1,36 +0,0 @@
-import spawn from 'cross-spawn'
-
-import { CliError } from './errors.js'
-
-export function spawnCommand(
-  command: string,
-  args: string[],
-  env: NodeJS.ProcessEnv,
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      env,
-      stdio: 'inherit',
-    })
-
-    child.once('error', reject)
-    child.once('close', (exitCode: number | null, signal: NodeJS.Signals | null) => {
-      if (signal) {
-        reject(new CliError(`Command terminated by signal ${signal}`))
-        return
-      }
-
-      if (exitCode === null) {
-        reject(new CliError('Command terminated without an exit code'))
-        return
-      }
-
-      if (exitCode !== 0) {
-        reject(new CliError(`Command exited with code ${exitCode}`, exitCode))
-        return
-      }
-
-      resolve()
-    })
-  })
-}