@lkangd/cc-env 1.0.0

package/tests/cli/restore.test.ts

@@ -0,0 +1,172 @@
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { execa } from 'execa'
+import { afterEach, describe, expect, it } from 'vitest'
+
+const repoRoot = fileURLToPath(new URL('../../', import.meta.url))
+const tsxLoader = join(repoRoot, 'node_modules/tsx/dist/loader.mjs')
+const cliEntry = join(repoRoot, 'src/cli.ts')
+
+const tempRoots: string[] = []
+
+async function createRestoreFixture({ latestIncludesExtraKey = false }: { latestIncludesExtraKey?: boolean } = {}) {
+  const root = await mkdtemp(join(tmpdir(), 'cc-env-restore-cli-'))
+  tempRoots.push(root)
+
+  const homeDir = join(root, 'home')
+  await mkdir(join(homeDir, '.claude'), { recursive: true })
+  await mkdir(join(homeDir, '.cc-env', 'history'), { recursive: true })
+  await mkdir(join(homeDir, '.config', 'fish'), { recursive: true })
+
+  await writeFile(
+    join(homeDir, '.claude', 'settings.json'),
+    `${JSON.stringify({ env: {} }, null, 2)}\n`,
+    'utf8',
+  )
+  await writeFile(
+    join(homeDir, '.claude', 'settings.local.json'),
+    `${JSON.stringify({ env: {} }, null, 2)}\n`,
+    'utf8',
+  )
+  await writeFile(
+    join(homeDir, '.config', 'fish', 'config.fish'),
+    [
+      '# >>> cc-env >>>',
+      'set -gx ANTHROPIC_AUTH_TOKEN "local-token"',
+      ...(latestIncludesExtraKey ? ['set -gx API_TIMEOUT_MS "3000000"'] : []),
+      '# <<< cc-env <<<',
+      '',
+    ].join('\n'),
+    'utf8',
+  )
+  await writeFile(
+    join(homeDir, '.cc-env', 'history', '2026-04-24T12-00-00.000Z.json'),
+    `${JSON.stringify({
+      timestamp: '2026-04-24T12:00:00.000Z',
+      action: 'init',
+      migratedKeys: ['ANTHROPIC_AUTH_TOKEN'],
+      sources: [
+        {
+          file: join(homeDir, '.claude', 'settings.json'),
+          backup: {},
+        },
+        {
+          file: join(homeDir, '.claude', 'settings.local.json'),
+          backup: {
+            ANTHROPIC_AUTH_TOKEN: 'local-token',
+          },
+        },
+      ],
+      shellWrites: [
+        {
+          shell: 'fish',
+          filePath: join(homeDir, '.config', 'fish', 'config.fish'),
+          env: {
+            ANTHROPIC_AUTH_TOKEN: 'local-token',
+          },
+        },
+      ],
+    }, null, 2)}\n`,
+    'utf8',
+  )
+
+  if (latestIncludesExtraKey) {
+    await writeFile(
+      join(homeDir, '.cc-env', 'history', '2026-04-25T12-00-00.000Z.json'),
+      `${JSON.stringify({
+        timestamp: '2026-04-25T12:00:00.000Z',
+        action: 'init',
+        migratedKeys: ['ANTHROPIC_AUTH_TOKEN', 'API_TIMEOUT_MS'],
+        sources: [
+          {
+            file: join(homeDir, '.claude', 'settings.json'),
+            backup: {},
+          },
+          {
+            file: join(homeDir, '.claude', 'settings.local.json'),
+            backup: {
+              ANTHROPIC_AUTH_TOKEN: 'local-token',
+              API_TIMEOUT_MS: '3000000',
+            },
+          },
+        ],
+        shellWrites: [
+          {
+            shell: 'fish',
+            filePath: join(homeDir, '.config', 'fish', 'config.fish'),
+            env: {
+              ANTHROPIC_AUTH_TOKEN: 'local-token',
+              API_TIMEOUT_MS: '3000000',
+            },
+          },
+        ],
+      }, null, 2)}\n`,
+      'utf8',
+    )
+  }
+
+  return { homeDir }
+}
+
+afterEach(async () => {
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
+
+describe('cc-env CLI restore', () => {
+  it('restores Claude settings from init history with --yes', async () => {
+    const { homeDir } = await createRestoreFixture()
+
+    const { stdout } = await execa(
+      'node',
+      ['--import', tsxLoader, cliEntry, 'restore', '--yes'],
+      {
+        cwd: repoRoot,
+        env: {
+          HOME: homeDir,
+        },
+      },
+    )
+
+    const settingsLocal = JSON.parse(
+      await readFile(join(homeDir, '.claude', 'settings.local.json'), 'utf8'),
+    ) as { env?: Record<string, string> }
+    const fishConfig = await readFile(join(homeDir, '.config', 'fish', 'config.fish'), 'utf8')
+
+    expect(stdout).toContain('Restore complete')
+    expect(settingsLocal.env).toEqual({
+      ANTHROPIC_AUTH_TOKEN: 'local-token',
+    })
+    expect(fishConfig).not.toContain('ANTHROPIC_AUTH_TOKEN')
+  })
+
+  it('restores the latest init record with extra migrated keys when using --yes', async () => {
+    const { homeDir } = await createRestoreFixture({ latestIncludesExtraKey: true })
+
+    await execa(
+      'node',
+      ['--import', tsxLoader, cliEntry, 'restore', '--yes'],
+      {
+        cwd: repoRoot,
+        env: {
+          HOME: homeDir,
+        },
+      },
+    )
+
+    const settingsLocal = JSON.parse(
+      await readFile(join(homeDir, '.claude', 'settings.local.json'), 'utf8'),
+    ) as { env?: Record<string, string> }
+    const fishConfig = await readFile(join(homeDir, '.config', 'fish', 'config.fish'), 'utf8')
+
+    expect(settingsLocal.env).toEqual({
+      ANTHROPIC_AUTH_TOKEN: 'local-token',
+      API_TIMEOUT_MS: '3000000',
+    })
+    expect(fishConfig).not.toContain('ANTHROPIC_AUTH_TOKEN')
+    expect(fishConfig).not.toContain('API_TIMEOUT_MS')
+    expect(fishConfig).not.toContain('# >>> cc-env >>>')
+  })
+})

package/tests/commands/create.test.ts

@@ -0,0 +1,263 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { describe, expect, it, vi, afterEach } from 'vitest'
+
+import { createPresetCreateCommand, readEnvFile } from '../../src/commands/preset/create.js'
+import { CliError } from '../../src/core/errors.js'
+
+const tempRoots: string[] = []
+
+async function createTempRoot() {
+  const root = await mkdtemp(join(tmpdir(), 'cc-env-create-'))
+  tempRoots.push(root)
+  return root
+}
+
+afterEach(async () => {
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
+
+describe('readEnvFile', () => {
+  it('reads a flat JSON file', async () => {
+    const root = await createTempRoot()
+    const file = join(root, 'env.json')
+    await writeFile(file, JSON.stringify({ API_KEY: 'secret', PORT: '3000' }))
+
+    const result = await readEnvFile(file)
+    expect(result.allKeys).toEqual(['API_KEY', 'PORT'])
+    expect(result.env).toEqual({ API_KEY: 'secret', PORT: '3000' })
+  })
+
+  it('extracts from nested env field in JSON', async () => {
+    const root = await createTempRoot()
+    const file = join(root, 'env.json')
+    await writeFile(file, JSON.stringify({ env: { API_KEY: 'secret' }, other: true }))
+
+    const result = await readEnvFile(file)
+    expect(result.allKeys).toEqual(['API_KEY'])
+    expect(result.env).toEqual({ API_KEY: 'secret' })
+  })
+
+  it('falls back to top-level when env is not an object', async () => {
+    const root = await createTempRoot()
+    const file = join(root, 'env.json')
+    await writeFile(file, JSON.stringify({ env: 'not-an-object', API_KEY: 'secret' }))
+
+    const result = await readEnvFile(file)
+    expect(result.env).toEqual({ API_KEY: 'secret' })
+  })
+
+  it('reads a YAML file', async () => {
+    const root = await createTempRoot()
+    const file = join(root, 'env.yaml')
+    await writeFile(file, 'API_KEY: secret\nPORT: "3000"\n')
+
+    const result = await readEnvFile(file)
+    expect(result.allKeys).toEqual(['API_KEY', 'PORT'])
+    expect(result.env).toEqual({ API_KEY: 'secret', PORT: '3000' })
+  })
+
+  it('throws for unsupported file extensions', async () => {
+    const root = await createTempRoot()
+    const file = join(root, 'env.toml')
+    await writeFile(file, 'content')
+
+    await expect(readEnvFile(file)).rejects.toThrowError(
+      new CliError('Unsupported file format: .toml', 2),
+    )
+  })
+
+  it('throws CliError for unreadable files', async () => {
+    await expect(readEnvFile('/nonexistent/file.json')).rejects.toThrowError(
+      expect.any(CliError),
+    )
+  })
+
+  it('throws CliError for invalid JSON content', async () => {
+    const root = await createTempRoot()
+    const file = join(root, 'env.json')
+    await writeFile(file, '{invalid')
+
+    await expect(readEnvFile(file)).rejects.toThrowError(
+      expect.any(CliError),
+    )
+  })
+})
+
+describe('createPresetCreateCommand', () => {
+  it('writes to presetService when destination is global', async () => {
+    const presetService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const projectEnvService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const ensureGitignore = vi.fn().mockResolvedValue(undefined)
+    const renderFlow = vi.fn().mockResolvedValue({
+      source: 'manual',
+      env: { API_KEY: 'secret' },
+      selectedKeys: ['API_KEY'],
+      presetName: 'my-preset',
+      destination: 'global',
+    })
+
+    const createPreset = createPresetCreateCommand({
+      presetService,
+      projectEnvService,
+      renderFlow,
+      ensureGitignore,
+    })
+
+    await createPreset({ cwd: '/project' })
+
+    expect(presetService.write).toHaveBeenCalledWith({
+      name: 'my-preset',
+      createdAt: expect.any(String),
+      updatedAt: expect.any(String),
+      env: { API_KEY: 'secret' },
+    })
+    expect(projectEnvService.write).not.toHaveBeenCalled()
+    expect(ensureGitignore).not.toHaveBeenCalled()
+  })
+
+  it('writes to projectEnvService when destination is project', async () => {
+    const presetService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const projectEnvService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const ensureGitignore = vi.fn().mockResolvedValue(undefined)
+    const renderFlow = vi.fn().mockResolvedValue({
+      source: 'file',
+      filePath: '/path/to/env.json',
+      env: { API_KEY: 'secret', OTHER: 'value' },
+      selectedKeys: ['API_KEY'],
+      presetName: 'proj',
+      destination: 'project',
+    })
+
+    const createPreset = createPresetCreateCommand({
+      presetService,
+      projectEnvService,
+      renderFlow,
+      ensureGitignore,
+    })
+
+    await createPreset({ cwd: '/project' })
+
+    expect(projectEnvService.write).toHaveBeenCalledWith({ API_KEY: 'secret' }, { name: 'proj', createdAt: expect.any(String), updatedAt: expect.any(String) })
+    expect(presetService.write).not.toHaveBeenCalled()
+  })
+
+  it('calls ensureGitignore when destination is project', async () => {
+    const presetService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const projectEnvService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const ensureGitignore = vi.fn().mockResolvedValue(undefined)
+    const renderFlow = vi.fn().mockResolvedValue({
+      source: 'manual',
+      env: { KEY: 'val' },
+      selectedKeys: ['KEY'],
+      presetName: 'test',
+      destination: 'project',
+    })
+
+    const createPreset = createPresetCreateCommand({
+      presetService,
+      projectEnvService,
+      renderFlow,
+      ensureGitignore,
+    })
+
+    await createPreset({ cwd: '/my-project' })
+
+    expect(ensureGitignore).toHaveBeenCalledWith('/my-project', '.cc-env')
+  })
+
+  it('does not call ensureGitignore when destination is global', async () => {
+    const presetService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const projectEnvService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const ensureGitignore = vi.fn().mockResolvedValue(undefined)
+    const renderFlow = vi.fn().mockResolvedValue({
+      source: 'manual',
+      env: { KEY: 'val' },
+      selectedKeys: ['KEY'],
+      presetName: 'test',
+      destination: 'global',
+    })
+
+    const createPreset = createPresetCreateCommand({
+      presetService,
+      projectEnvService,
+      renderFlow,
+      ensureGitignore,
+    })
+
+    await createPreset({ cwd: '/my-project' })
+
+    expect(ensureGitignore).not.toHaveBeenCalled()
+  })
+
+  it('does nothing when renderFlow returns undefined', async () => {
+    const presetService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const projectEnvService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const renderFlow = vi.fn().mockResolvedValue(undefined)
+
+    const createPreset = createPresetCreateCommand({
+      presetService,
+      projectEnvService,
+      renderFlow,
+    })
+
+    await createPreset({ cwd: '/project' })
+
+    expect(presetService.write).not.toHaveBeenCalled()
+    expect(projectEnvService.write).not.toHaveBeenCalled()
+  })
+
+  it('only includes selected keys in the written env', async () => {
+    const presetService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const projectEnvService = {
+      write: vi.fn().mockResolvedValue(undefined),
+    }
+    const renderFlow = vi.fn().mockResolvedValue({
+      source: 'file',
+      filePath: '/env.json',
+      env: { A: '1', B: '2', C: '3' },
+      selectedKeys: ['A', 'C'],
+      presetName: 'partial',
+      destination: 'global',
+    })
+
+    const createPreset = createPresetCreateCommand({
+      presetService,
+      projectEnvService,
+      renderFlow,
+    })
+
+    await createPreset({ cwd: '/project' })
+
+    expect(presetService.write).toHaveBeenCalledWith({
+      name: 'partial',
+      createdAt: expect.any(String),
+      updatedAt: expect.any(String),
+      env: { A: '1', C: '3' },
+    })
+  })
+})

package/tests/commands/output.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { createDeletePresetCommand } from '../../src/commands/preset/delete.js'
+import { formatEnvBlock, formatRestorePreview } from '../../src/core/format.js'
+
+const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+afterEach(() => {
+  logSpy.mockClear()
+})
+
+describe('formatEnvBlock', () => {
+  it('masks sensitive values', () => {
+    expect(
+      formatEnvBlock({
+        OPENAI_API_KEY: 'sk-1234567890',
+        BASE_URL: 'https://api.openai.com',
+      }),
+    ).toBe('BASE_URL=https://api.openai.com\nOPENAI_API_KEY=sk-123456********')
+  })
+})
+
+describe('formatRestorePreview', () => {
+  it('shows restore values as newline-delimited key=value entries without masking', () => {
+    expect(
+      formatRestorePreview({
+        OPENAI_API_KEY: 'sk-123',
+        BASE_URL: 'https://api.openai.com',
+      }),
+    ).toBe('BASE_URL=https://api.openai.com\nOPENAI_API_KEY=sk-123')
+  })
+})
+
+describe('createDeletePresetCommand', () => {
+  it('deletes selected global preset and prints success message', async () => {
+    const remove = vi.fn().mockResolvedValue(undefined)
+    const deletePreset = createDeletePresetCommand({
+      presetService: {
+        listNames: vi.fn().mockResolvedValue(['openai', 'anthropic']),
+        read: vi.fn().mockResolvedValue({ env: { API_KEY: 'test' } }),
+        remove,
+      },
+      projectEnvService: {
+        readWithMeta: vi.fn().mockResolvedValue({ env: {} }),
+        write: vi.fn(),
+      },
+      renderDelete: vi.fn().mockResolvedValue({ name: 'anthropic', env: { API_KEY: 'test' }, source: 'global' }),
+    })
+
+    await deletePreset()
+
+    expect(remove).toHaveBeenCalledWith('anthropic')
+    expect(logSpy).toHaveBeenCalledWith('Deleted preset: anthropic')
+  })
+
+  it('deletes project preset by writing empty env', async () => {
+    const remove = vi.fn().mockResolvedValue(undefined)
+    const write = vi.fn().mockResolvedValue({})
+    const deletePreset = createDeletePresetCommand({
+      presetService: {
+        listNames: vi.fn().mockResolvedValue([]),
+        read: vi.fn(),
+        remove,
+      },
+      projectEnvService: {
+        readWithMeta: vi.fn().mockResolvedValue({ env: { KEY: 'val' }, name: 'my-proj' }),
+        write,
+      },
+      renderDelete: vi.fn().mockResolvedValue({ name: 'my-proj', env: { KEY: 'val' }, source: 'project' }),
+    })
+
+    await deletePreset()
+
+    expect(write).toHaveBeenCalledWith({})
+    expect(remove).not.toHaveBeenCalled()
+    expect(logSpy).toHaveBeenCalledWith('Deleted preset: my-proj')
+  })
+
+  it('prints message when no presets exist', async () => {
+    const remove = vi.fn().mockResolvedValue(undefined)
+    const deletePreset = createDeletePresetCommand({
+      presetService: {
+        listNames: vi.fn().mockResolvedValue([]),
+        read: vi.fn(),
+        remove,
+      },
+      projectEnvService: {
+        readWithMeta: vi.fn().mockResolvedValue({ env: {} }),
+        write: vi.fn(),
+      },
+      renderDelete: vi.fn(),
+    })
+
+    await deletePreset()
+
+    expect(logSpy).toHaveBeenCalledWith('No presets found.')
+    expect(remove).not.toHaveBeenCalled()
+  })
+
+  it('does nothing when user cancels', async () => {
+    const remove = vi.fn().mockResolvedValue(undefined)
+    const deletePreset = createDeletePresetCommand({
+      presetService: {
+        listNames: vi.fn().mockResolvedValue(['openai']),
+        read: vi.fn().mockResolvedValue({ env: { API_KEY: 'test' } }),
+        remove,
+      },
+      projectEnvService: {
+        readWithMeta: vi.fn().mockResolvedValue({ env: {} }),
+        write: vi.fn(),
+      },
+      renderDelete: vi.fn().mockResolvedValue(undefined),
+    })
+
+    await deletePreset()
+
+    expect(remove).not.toHaveBeenCalled()
+  })
+})