@lkangd/cc-env 1.0.0

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

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

@@ -0,0 +1,183 @@
+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,}/)
+  })
+})