@lkangd/cc-env 1.1.1 → 1.2.0

package/tests/integration/init-restore.test.ts

@@ -1,406 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { createInitCommand } from '../../src/commands/init.js'
-import { createRestoreCommand } from '../../src/commands/restore.js'
-
-const globalSettingsPath = '/Users/test/.claude/settings.json'
-const globalSettingsLocalPath = '/Users/test/.claude/settings.local.json'
-const projectSettingsPath = '/project/.claude/settings.json'
-const projectSettingsLocalPath = '/project/.claude/settings.local.json'
-
-const allPaths = [globalSettingsPath, globalSettingsLocalPath, projectSettingsPath, projectSettingsLocalPath]
-
-describe('createInitCommand', () => {
-  it('migrates effective env from Claude settings into shell blocks and records per-file backups', async () => {
-    const claudeSettingsEnvService = {
-      read: vi.fn().mockResolvedValue([
-        { path: globalSettingsPath, exists: true, env: { ANTHROPIC_BASE_URL: 'https://settings.example.com' } },
-        { path: globalSettingsLocalPath, exists: true, env: { ANTHROPIC_AUTH_TOKEN: 'local-token', ANTHROPIC_BASE_URL: 'https://local.example.com' } },
-        { path: projectSettingsPath, exists: false, env: {} },
-        { path: projectSettingsLocalPath, exists: false, env: {} },
-      ]),
-      write: vi.fn().mockResolvedValue(undefined),
-    }
-    const shellEnvService = {
-      write: vi.fn().mockResolvedValue([
-        {
-          shell: 'zsh',
-          filePath: '/Users/test/.zshrc',
-          env: {
-            ANTHROPIC_AUTH_TOKEN: 'local-token',
-            ANTHROPIC_BASE_URL: 'https://local.example.com',
-          },
-        },
-      ]),
-    }
-    const historyService = {
-      write: vi.fn().mockResolvedValue(undefined),
-    }
-    const renderFlow = vi.fn().mockResolvedValue({
-      confirmed: true,
-      selectedKeys: ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL'],
-    })
-
-    const init = createInitCommand({
-      claudeSettingsEnvService,
-      shellEnvService,
-      historyService,
-      renderFlow,
-      renderEnvSummary: vi.fn().mockResolvedValue(undefined),
-    })
-
-    await expect(init({ yes: false })).resolves.toBeUndefined()
-
-    expect(renderFlow).toHaveBeenCalledWith({
-      keys: ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL'],
-      requiredKeys: ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL'],
-      sourceFiles: allPaths,
-      yes: false,
-    })
-    expect(shellEnvService.write).toHaveBeenCalledWith({
-      ANTHROPIC_AUTH_TOKEN: 'local-token',
-      ANTHROPIC_BASE_URL: 'https://local.example.com',
-    })
-    expect(historyService.write).toHaveBeenCalledWith({
-      timestamp: expect.any(String),
-      action: 'init',
-      migratedKeys: ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL'],
-      sources: [
-        {
-          file: globalSettingsPath,
-          backup: {
-            ANTHROPIC_BASE_URL: 'https://settings.example.com',
-          },
-        },
-        {
-          file: globalSettingsLocalPath,
-          backup: {
-            ANTHROPIC_AUTH_TOKEN: 'local-token',
-            ANTHROPIC_BASE_URL: 'https://local.example.com',
-          },
-        },
-        {
-          file: projectSettingsPath,
-          backup: {},
-        },
-        {
-          file: projectSettingsLocalPath,
-          backup: {},
-        },
-      ],
-      shellWrites: [
-        {
-          shell: 'zsh',
-          filePath: '/Users/test/.zshrc',
-          env: {
-            ANTHROPIC_AUTH_TOKEN: 'local-token',
-            ANTHROPIC_BASE_URL: 'https://local.example.com',
-          },
-        },
-      ],
-    })
-    expect(claudeSettingsEnvService.write).toHaveBeenCalledWith([
-      { path: globalSettingsPath, env: {} },
-      { path: globalSettingsLocalPath, env: {} },
-      { path: projectSettingsPath, env: {} },
-      { path: projectSettingsLocalPath, env: {} },
-    ])
-  })
-
-  it('fails when all Claude settings files are missing', async () => {
-    const init = createInitCommand({
-      claudeSettingsEnvService: {
-        read: vi.fn().mockResolvedValue([
-          { path: globalSettingsPath, exists: false, env: {} },
-          { path: globalSettingsLocalPath, exists: false, env: {} },
-          { path: projectSettingsPath, exists: false, env: {} },
-          { path: projectSettingsLocalPath, exists: false, env: {} },
-        ]),
-        write: vi.fn(),
-      },
-      shellEnvService: { write: vi.fn() },
-      historyService: { write: vi.fn() },
-      renderFlow: vi.fn(),
-      renderEnvSummary: vi.fn().mockResolvedValue(undefined),
-    })
-
-    await expect(init({ yes: false })).rejects.toMatchObject({
-      message: 'No Claude settings files were found',
-      exitCode: 1,
-    })
-  })
-})
-
-describe('createRestoreCommand', () => {
-  it('restores an init record by removing shell keys and restoring both Claude settings files', async () => {
-    const historyService = {
-      list: vi.fn().mockResolvedValue([
-        {
-          timestamp: '2026-04-24T00:00:00.000Z',
-          action: 'init',
-          migratedKeys: ['ANTHROPIC_AUTH_TOKEN'],
-          sources: [
-            {
-              file: globalSettingsPath,
-              backup: {},
-            },
-            {
-              file: globalSettingsLocalPath,
-              backup: {
-                ANTHROPIC_AUTH_TOKEN: 'local-token',
-              },
-            },
-          ],
-          shellWrites: [
-            {
-              shell: 'zsh',
-              filePath: '/Users/test/.zshrc',
-              env: {
-                ANTHROPIC_AUTH_TOKEN: 'local-token',
-              },
-            },
-          ],
-        },
-      ]),
-    }
-    const claudeSettingsEnvService = {
-      read: vi.fn().mockResolvedValue([
-        { path: globalSettingsPath, exists: true, env: {} },
-        { path: globalSettingsLocalPath, exists: true, env: {} },
-        { path: projectSettingsPath, exists: false, env: {} },
-        { path: projectSettingsLocalPath, exists: false, env: {} },
-      ]),
-      write: vi.fn().mockResolvedValue(undefined),
-    }
-    const shellEnvService = {
-      removeKeys: vi.fn().mockResolvedValue(undefined),
-    }
-    const presetService = {
-      read: vi.fn(),
-      write: vi.fn(),
-    }
-    const renderFlow = vi.fn().mockResolvedValue({
-      confirmed: true,
-      timestamp: '2026-04-24T00:00:00.000Z',
-    })
-
-    const restore = createRestoreCommand({
-      historyService,
-      claudeSettingsEnvService,
-      shellEnvService,
-      settingsEnvService: {
-        read: vi.fn(),
-        write: vi.fn(),
-      },
-      presetService,
-      renderEnvSummary: vi.fn().mockResolvedValue(undefined),
-      renderFlow,
-    })
-
-    await expect(restore({ yes: false })).resolves.toBeUndefined()
-
-    expect(shellEnvService.removeKeys).toHaveBeenCalledWith(
-      [
-        {
-          shell: 'zsh',
-          filePath: '/Users/test/.zshrc',
-          env: {
-            ANTHROPIC_AUTH_TOKEN: 'local-token',
-          },
-        },
-      ],
-      ['ANTHROPIC_AUTH_TOKEN'],
-    )
-    expect(claudeSettingsEnvService.write).toHaveBeenCalledWith([
-      { path: globalSettingsPath, env: {} },
-      { path: globalSettingsLocalPath, env: { ANTHROPIC_AUTH_TOKEN: 'local-token' } },
-      { path: projectSettingsPath, env: {} },
-      { path: projectSettingsLocalPath, env: {} },
-    ])
-    expect(presetService.read).not.toHaveBeenCalled()
-    expect(presetService.write).not.toHaveBeenCalled()
-  })
-
-  it('restores the selected latest init record including extra migrated keys', async () => {
-    const historyService = {
-      list: vi.fn().mockResolvedValue([
-        {
-          timestamp: '2026-04-24T00:00:00.000Z',
-          action: 'init',
-          migratedKeys: ['ANTHROPIC_AUTH_TOKEN'],
-          sources: [
-            {
-              file: globalSettingsPath,
-              backup: {},
-            },
-            {
-              file: globalSettingsLocalPath,
-              backup: {
-                ANTHROPIC_AUTH_TOKEN: 'old-local-token',
-              },
-            },
-          ],
-          shellWrites: [
-            {
-              shell: 'fish',
-              filePath: '/Users/test/.config/fish/config.fish',
-              env: {
-                ANTHROPIC_AUTH_TOKEN: 'old-local-token',
-              },
-            },
-          ],
-        },
-        {
-          timestamp: '2026-04-25T00:00:00.000Z',
-          action: 'init',
-          migratedKeys: ['ANTHROPIC_AUTH_TOKEN', 'API_TIMEOUT_MS'],
-          sources: [
-            {
-              file: globalSettingsPath,
-              backup: {},
-            },
-            {
-              file: globalSettingsLocalPath,
-              backup: {
-                ANTHROPIC_AUTH_TOKEN: 'local-token',
-                API_TIMEOUT_MS: '3000000',
-              },
-            },
-          ],
-          shellWrites: [
-            {
-              shell: 'fish',
-              filePath: '/Users/test/.config/fish/config.fish',
-              env: {
-                ANTHROPIC_AUTH_TOKEN: 'local-token',
-                API_TIMEOUT_MS: '3000000',
-              },
-            },
-          ],
-        },
-      ]),
-    }
-    const claudeSettingsEnvService = {
-      read: vi.fn().mockResolvedValue([
-        { path: globalSettingsPath, exists: true, env: {} },
-        { path: globalSettingsLocalPath, exists: true, env: {} },
-        { path: projectSettingsPath, exists: false, env: {} },
-        { path: projectSettingsLocalPath, exists: false, env: {} },
-      ]),
-      write: vi.fn().mockResolvedValue(undefined),
-    }
-    const shellEnvService = {
-      removeKeys: vi.fn().mockResolvedValue(undefined),
-    }
-    const presetService = {
-      read: vi.fn(),
-      write: vi.fn(),
-    }
-    const renderFlow = vi.fn().mockResolvedValue({
-      confirmed: true,
-      timestamp: '2026-04-25T00:00:00.000Z',
-    })
-
-    const restore = createRestoreCommand({
-      historyService,
-      claudeSettingsEnvService,
-      shellEnvService,
-      settingsEnvService: {
-        read: vi.fn(),
-        write: vi.fn(),
-      },
-      presetService,
-      renderEnvSummary: vi.fn().mockResolvedValue(undefined),
-      renderFlow,
-    })
-
-    await expect(restore({ yes: false })).resolves.toBeUndefined()
-
-    expect(shellEnvService.removeKeys).toHaveBeenCalledWith(
-      [
-        {
-          shell: 'fish',
-          filePath: '/Users/test/.config/fish/config.fish',
-          env: {
-            ANTHROPIC_AUTH_TOKEN: 'local-token',
-            API_TIMEOUT_MS: '3000000',
-          },
-        },
-      ],
-      ['ANTHROPIC_AUTH_TOKEN', 'API_TIMEOUT_MS'],
-    )
-    expect(claudeSettingsEnvService.write).toHaveBeenCalledWith([
-      { path: globalSettingsPath, env: {} },
-      { path: globalSettingsLocalPath, env: { ANTHROPIC_AUTH_TOKEN: 'local-token', API_TIMEOUT_MS: '3000000' } },
-      { path: projectSettingsPath, env: {} },
-      { path: projectSettingsLocalPath, env: {} },
-    ])
-  })
-
-  it('restores a non-init history record into a preset', async () => {
-    const historyService = {
-      list: vi.fn().mockResolvedValue([
-        {
-          timestamp: '2026-04-25T00:00:00.000Z',
-          action: 'restore',
-          targetType: 'preset',
-          targetName: 'openai',
-          backup: {
-            OPENAI_API_KEY: 'sk-123',
-          },
-        },
-      ]),
-    }
-    const settingsEnvService = {
-      read: vi.fn(),
-      write: vi.fn(),
-    }
-    const presetService = {
-      read: vi.fn().mockResolvedValue({
-        name: 'openai',
-        createdAt: '2026-04-24T00:00:00.000Z',
-        updatedAt: '2026-04-24T00:00:00.000Z',
-        env: {
-          BASE_URL: 'https://api.openai.com',
-        },
-      }),
-      write: vi.fn().mockResolvedValue(undefined),
-    }
-    const renderFlow = vi.fn().mockResolvedValue({
-      confirmed: true,
-      timestamp: '2026-04-25T00:00:00.000Z',
-      targetType: 'preset',
-      targetName: 'openai',
-    })
-
-    const restore = createRestoreCommand({
-      historyService,
-      claudeSettingsEnvService: {
-        read: vi.fn(),
-        write: vi.fn(),
-      },
-      shellEnvService: {
-        removeKeys: vi.fn(),
-      },
-      settingsEnvService,
-      presetService,
-      renderEnvSummary: vi.fn().mockResolvedValue(undefined),
-      renderFlow,
-    })
-
-    await expect(restore({ yes: false })).resolves.toBeUndefined()
-
-    expect(presetService.read).toHaveBeenCalledWith('openai')
-    expect(presetService.write).toHaveBeenCalledWith({
-      name: 'openai',
-      createdAt: '2026-04-24T00:00:00.000Z',
-      updatedAt: expect.any(String),
-      env: {
-        BASE_URL: 'https://api.openai.com',
-        OPENAI_API_KEY: 'sk-123',
-      },
-    })
-    expect(settingsEnvService.read).not.toHaveBeenCalled()
-    expect(settingsEnvService.write).not.toHaveBeenCalled()
-  })
-})

package/tests/services/claude-shell.test.ts

@@ -1,183 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { createClaudeSettingsEnvService } from '../../src/services/claude-settings-env-service.js'
-import { createShellEnvService } from '../../src/services/shell-env-service.js'
-
-const roots: string[] = []
-
-afterEach(async () => {
-  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
-})
-
-describe('Claude settings env service', () => {
-  it('reads all four settings files with correct priority order', async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), 'cc-env-home-'))
-    const cwd = await mkdtemp(join(tmpdir(), 'cc-env-cwd-'))
-    roots.push(homeDir, cwd)
-
-    await mkdir(join(homeDir, '.claude'), { recursive: true })
-    await writeFile(
-      join(homeDir, '.claude', 'settings.json'),
-      '{"env":{"KEY_A":"global-settings","KEY_B":"global-only"}}\n',
-      'utf8',
-    )
-    await writeFile(
-      join(homeDir, '.claude', 'settings.local.json'),
-      '{"env":{"KEY_A":"global-local","KEY_C":"global-local-only"}}\n',
-      'utf8',
-    )
-
-    await mkdir(join(cwd, '.claude'), { recursive: true })
-    await writeFile(
-      join(cwd, '.claude', 'settings.json'),
-      '{"env":{"KEY_A":"project-settings","KEY_D":"project-only"}}\n',
-      'utf8',
-    )
-    await writeFile(
-      join(cwd, '.claude', 'settings.local.json'),
-      '{"env":{"KEY_A":"project-local","KEY_E":"project-local-only"}}\n',
-      'utf8',
-    )
-
-    const service = createClaudeSettingsEnvService({ homeDir, cwd })
-    const sources = await service.read()
-
-    expect(sources).toHaveLength(4)
-    expect(sources[0]).toMatchObject({
-      exists: true,
-      env: { KEY_A: 'global-settings', KEY_B: 'global-only' },
-    })
-    expect(sources[1]).toMatchObject({
-      exists: true,
-      env: { KEY_A: 'global-local', KEY_C: 'global-local-only' },
-    })
-    expect(sources[2]).toMatchObject({
-      exists: true,
-      env: { KEY_A: 'project-settings', KEY_D: 'project-only' },
-    })
-    expect(sources[3]).toMatchObject({
-      exists: true,
-      env: { KEY_A: 'project-local', KEY_E: 'project-local-only' },
-    })
-  })
-
-  it('handles missing files gracefully', async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), 'cc-env-home-'))
-    const cwd = await mkdtemp(join(tmpdir(), 'cc-env-cwd-'))
-    roots.push(homeDir, cwd)
-
-    await mkdir(join(homeDir, '.claude'), { recursive: true })
-    await writeFile(
-      join(homeDir, '.claude', 'settings.json'),
-      '{"env":{"KEY_A":"global-settings"}}\n',
-      'utf8',
-    )
-
-    const service = createClaudeSettingsEnvService({ homeDir, cwd })
-    const sources = await service.read()
-
-    expect(sources).toHaveLength(4)
-    expect(sources[0]!.exists).toBe(true)
-    expect(sources[1]!.exists).toBe(false)
-    expect(sources[2]!.exists).toBe(false)
-    expect(sources[3]!.exists).toBe(false)
-  })
-
-  it('preserves sibling fields when writing updated env values', async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), 'cc-env-home-'))
-    roots.push(homeDir)
-
-    await mkdir(join(homeDir, '.claude'), { recursive: true })
-    await writeFile(
-      join(homeDir, '.claude', 'settings.json'),
-      `${JSON.stringify({
-        theme: 'dark',
-        env: {
-          ANTHROPIC_BASE_URL: 'https://settings.example.com',
-        },
-      }, null, 2)}\n`,
-      'utf8',
-    )
-    await writeFile(
-      join(homeDir, '.claude', 'settings.local.json'),
-      `${JSON.stringify({
-        permissions: { allow: ['Bash'] },
-        env: {
-          ANTHROPIC_AUTH_TOKEN: 'local-token',
-        },
-      }, null, 2)}\n`,
-      'utf8',
-    )
-
-    const service = createClaudeSettingsEnvService({ homeDir })
-
-    const sources = await service.read()
-    await service.write(sources.map((s) => ({ path: s.path, env: {} })))
-
-    await expect(readFile(join(homeDir, '.claude', 'settings.json'), 'utf8')).resolves.toContain(
-      '"theme": "dark"',
-    )
-    await expect(readFile(join(homeDir, '.claude', 'settings.local.json'), 'utf8')).resolves.toContain(
-      '"permissions"',
-    )
-  })
-})
-
-describe('shell env service', () => {
-  it('writes and updates only the managed block in all shell files', async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), 'cc-env-shell-'))
-    roots.push(homeDir)
-
-    await writeFile(join(homeDir, '.zshrc'), 'export PATH="/bin"\n', 'utf8')
-
-    const service = createShellEnvService({ homeDir })
-
-    await service.write({
-      ANTHROPIC_AUTH_TOKEN: 'local-token',
-    })
-
-    await expect(readFile(join(homeDir, '.zshrc'), 'utf8')).resolves.toContain(
-      '# >>> cc-env >>>',
-    )
-    await expect(readFile(join(homeDir, '.zshrc'), 'utf8')).resolves.toContain(
-      'export ANTHROPIC_AUTH_TOKEN="local-token"',
-    )
-  })
-
-  it('removes only the requested keys from a managed block and leaves user content intact', async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), 'cc-env-shell-'))
-    roots.push(homeDir)
-
-    const service = createShellEnvService({ homeDir })
-    const shellWrites = await service.write({
-      ANTHROPIC_AUTH_TOKEN: 'local-token',
-      ANTHROPIC_BASE_URL: 'https://local.example.com',
-    })
-
-    await service.removeKeys(shellWrites, ['ANTHROPIC_AUTH_TOKEN'])
-
-    await expect(readFile(join(homeDir, '.bashrc'), 'utf8')).resolves.not.toContain(
-      'ANTHROPIC_AUTH_TOKEN',
-    )
-    await expect(readFile(join(homeDir, '.bashrc'), 'utf8')).resolves.toContain(
-      'ANTHROPIC_BASE_URL',
-    )
-  })
-
-  it('collapses blank lines when removing all keys', async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), 'cc-env-shell-'))
-    roots.push(homeDir)
-
-    const service = createShellEnvService({ homeDir })
-    const shellWrites = await service.write({ API_KEY: 'secret' })
-
-    await service.removeKeys(shellWrites, ['API_KEY'])
-
-    const content = await readFile(join(homeDir, '.zshrc'), 'utf8')
-    expect(content).not.toMatch(/\n{3,}/)
-  })
-})