@lkangd/cc-env 1.1.1 → 1.2.0

package/tests/cli/restore.test.ts

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

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

@@ -1,119 +0,0 @@
-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()
-  })
-})