@lkangd/cc-env 1.0.0

package/tests/commands/run.test.ts

@@ -0,0 +1,218 @@
+import { rm } from 'node:fs/promises'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { createRunCommand } from '../../src/commands/run.js'
+import { CliError } from '../../src/core/errors.js'
+import type { EnvMap } from '../../src/core/schema.js'
+
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+const emptySettingsSources = [
+  { path: '/home/.claude/settings.json', exists: false, env: {} as EnvMap },
+  { path: '/home/.claude/settings.local.json', exists: false, env: {} as EnvMap },
+  { path: '/project/.claude/settings.json', exists: false, env: {} as EnvMap },
+  { path: '/project/.claude/settings.local.json', exists: false, env: {} as EnvMap },
+]
+
+type PresetRef = { presetName: string; source: 'global' | 'project' }
+type PresetSelectItem = { name: string; env: EnvMap; source: 'global' | 'project' }
+
+function createMocks(overrides: Partial<{
+  claudeSettingsEnvService: { read: () => Promise<typeof emptySettingsSources> }
+  presetService: { listNames: () => Promise<string[]>; read: (name: string) => Promise<{ env: EnvMap }> }
+  projectEnvService: { readWithMeta: () => Promise<{ env: EnvMap; name?: string | undefined }> }
+  projectStateService: { getLastPreset: (cwd: string) => Promise<PresetRef | undefined>; saveLastPreset: (cwd: string, ref: PresetRef) => Promise<void> }
+  findClaude: () => string
+  renderPresetSelect: (input: { presets: Array<PresetSelectItem>; defaultIndex: number }) => Promise<PresetSelectItem | undefined>
+  spawnCommand: (command: string, args: string[], env: NodeJS.ProcessEnv) => Promise<void>
+  stdout: Pick<NodeJS.WriteStream, 'write'>
+}> = {}) {
+  const defaultPreset = { env: { OPENAI_API_KEY: 'sk-1234567890' } as EnvMap }
+  const presetItem = { name: 'openai', env: defaultPreset.env, source: 'global' as const }
+
+  return {
+    claudeSettingsEnvService: overrides.claudeSettingsEnvService ?? {
+      read: vi.fn().mockResolvedValue(emptySettingsSources),
+    },
+    presetService: overrides.presetService ?? {
+      listNames: vi.fn().mockResolvedValue(['openai']),
+      read: vi.fn().mockResolvedValue(defaultPreset),
+    },
+    projectEnvService: overrides.projectEnvService ?? {
+      readWithMeta: vi.fn().mockResolvedValue({ env: {} as EnvMap }),
+    },
+    projectStateService: overrides.projectStateService ?? {
+      getLastPreset: vi.fn().mockResolvedValue(undefined),
+      saveLastPreset: vi.fn().mockResolvedValue(undefined),
+    },
+    findClaude: overrides.findClaude ?? vi.fn().mockReturnValue('/usr/local/bin/claude'),
+    renderPresetSelect: overrides.renderPresetSelect ?? vi.fn().mockResolvedValue(presetItem),
+    spawnCommand: overrides.spawnCommand ?? vi.fn().mockResolvedValue(undefined),
+    stdout: overrides.stdout ?? { write: vi.fn() },
+  }
+}
+
+function buildRun(mocks: ReturnType<typeof createMocks>) {
+  return createRunCommand({
+    claudeSettingsEnvService: mocks.claudeSettingsEnvService,
+    presetService: mocks.presetService,
+    projectEnvService: mocks.projectEnvService,
+    projectStateService: mocks.projectStateService,
+    findClaude: mocks.findClaude,
+    renderPresetSelect: mocks.renderPresetSelect,
+    spawnCommand: mocks.spawnCommand,
+    stdout: mocks.stdout,
+  })
+}
+
+describe('createRunCommand', () => {
+  it('throws when init-managed keys found in Claude settings', async () => {
+    const staleSources = emptySettingsSources.map((s, i) =>
+      i === 0 ? { ...s, exists: true, env: { ANTHROPIC_AUTH_TOKEN: 'sk-old' } as EnvMap } : s,
+    )
+    const mocks = createMocks({
+      claudeSettingsEnvService: { read: vi.fn().mockResolvedValue(staleSources) },
+    })
+
+    await expect(buildRun(mocks)({ cwd: '/project' })).rejects.toEqual(
+      new CliError('Found init-managed keys in Claude settings:\n\n  ANTHROPIC_AUTH_TOKEN. \n\n  Run "cc-env init" first.'),
+    )
+  })
+
+  it('throws when no presets exist', async () => {
+    const mocks = createMocks({
+      presetService: {
+        listNames: vi.fn().mockResolvedValue([]),
+        read: vi.fn(),
+      },
+      projectEnvService: {
+        readWithMeta: vi.fn().mockResolvedValue({ env: {} as EnvMap }),
+      },
+    })
+
+    await expect(buildRun(mocks)({ cwd: '/project' })).rejects.toEqual(
+      new CliError('No presets found. Create one with "cc-env preset create".'),
+    )
+  })
+
+  it('returns cleanly when user cancels preset selection', async () => {
+    const mocks = createMocks({
+      renderPresetSelect: vi.fn().mockResolvedValue(undefined),
+    })
+
+    await buildRun(mocks)({ cwd: '/project' })
+
+    expect(mocks.spawnCommand).not.toHaveBeenCalled()
+    expect(mocks.projectStateService.saveLastPreset).not.toHaveBeenCalled()
+  })
+
+  it('auto-finds claude when no args provided', async () => {
+    const mocks = createMocks({
+      findClaude: vi.fn().mockReturnValue('/usr/local/bin/claude'),
+    })
+
+    await buildRun(mocks)({ args: [], cwd: '/project' })
+
+    expect(mocks.findClaude).toHaveBeenCalled()
+    expect(mocks.spawnCommand).toHaveBeenCalledWith(
+      '/usr/local/bin/claude',
+      [],
+      expect.objectContaining({ OPENAI_API_KEY: 'sk-1234567890' }),
+    )
+  })
+
+  it('uses claude directly when args[0] is "claude"', async () => {
+    const mocks = createMocks()
+
+    await buildRun(mocks)({ args: ['claude', '--model', 'opus'], cwd: '/project' })
+
+    expect(mocks.findClaude).not.toHaveBeenCalled()
+    expect(mocks.spawnCommand).toHaveBeenCalledWith(
+      'claude',
+      ['--model', 'opus'],
+      expect.objectContaining({ OPENAI_API_KEY: 'sk-1234567890' }),
+    )
+  })
+
+  it('saves last-selected preset after selection', async () => {
+    const mocks = createMocks()
+
+    await buildRun(mocks)({ cwd: '/project' })
+
+    expect(mocks.projectStateService.saveLastPreset).toHaveBeenCalledWith('/project', {
+      presetName: 'openai',
+      source: 'global',
+    })
+  })
+
+  it('uses saved preset as default selection index', async () => {
+    const mocks = createMocks({
+      projectStateService: {
+        getLastPreset: vi.fn().mockResolvedValue({ presetName: 'openai', source: 'global' }),
+        saveLastPreset: vi.fn().mockResolvedValue(undefined),
+      },
+    })
+
+    await buildRun(mocks)({ cwd: '/project' })
+
+    expect(mocks.renderPresetSelect).toHaveBeenCalledWith(
+      expect.objectContaining({ defaultIndex: 0 }),
+    )
+  })
+
+  it('falls back to index 0 when saved preset no longer exists', async () => {
+    const mocks = createMocks({
+      projectStateService: {
+        getLastPreset: vi.fn().mockResolvedValue({ presetName: 'deleted', source: 'global' }),
+        saveLastPreset: vi.fn().mockResolvedValue(undefined),
+      },
+    })
+
+    await buildRun(mocks)({ cwd: '/project' })
+
+    expect(mocks.renderPresetSelect).toHaveBeenCalledWith(
+      expect.objectContaining({ defaultIndex: 0 }),
+    )
+  })
+
+  it('prints env vars and preset info before spawning', async () => {
+    const mocks = createMocks()
+
+    await buildRun(mocks)({ args: ['claude'], cwd: '/project' })
+
+    expect(mocks.stdout.write).toHaveBeenCalledWith(
+      expect.stringContaining('Using preset: openai (global)'),
+    )
+    expect(mocks.stdout.write).toHaveBeenCalledWith(
+      expect.stringContaining('OPENAI_API_KEY=sk-123456********'),
+    )
+  })
+
+  it('prints would-run in dry-run mode without spawning', async () => {
+    const mocks = createMocks()
+
+    await buildRun(mocks)({ args: ['claude', '--model', 'opus'], dryRun: true, cwd: '/project' })
+
+    expect(mocks.stdout.write).toHaveBeenCalledWith(
+      expect.stringContaining('Would run: claude --model opus'),
+    )
+    expect(mocks.spawnCommand).not.toHaveBeenCalled()
+  })
+
+  it('auto-selects default preset in yes mode without rendering UI', async () => {
+    const mocks = createMocks()
+
+    await buildRun(mocks)({ yes: true, cwd: '/project' })
+
+    expect(mocks.renderPresetSelect).not.toHaveBeenCalled()
+    expect(mocks.projectStateService.saveLastPreset).toHaveBeenCalledWith('/project', {
+      presetName: 'openai',
+      source: 'global',
+    })
+  })
+})

package/tests/core/gitignore.test.ts

@@ -0,0 +1,98 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { ensureGitignoreEntry, isGitRepo } from '../../src/core/gitignore.js'
+
+const tempRoots: string[] = []
+
+async function createTempDir() {
+  const dir = await mkdtemp(join(tmpdir(), 'cc-env-git-'))
+  tempRoots.push(dir)
+  return dir
+}
+
+afterEach(async () => {
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
+
+describe('isGitRepo', () => {
+  it('returns true when .git exists', async () => {
+    const dir = await createTempDir()
+    await mkdir(join(dir, '.git'))
+
+    expect(isGitRepo(dir)).toBe(true)
+  })
+
+  it('returns false when .git is missing', async () => {
+    const dir = await createTempDir()
+
+    expect(isGitRepo(dir)).toBe(false)
+  })
+})
+
+describe('ensureGitignoreEntry', () => {
+  it('creates .gitignore if missing', async () => {
+    const dir = await createTempDir()
+    await mkdir(join(dir, '.git'))
+
+    await ensureGitignoreEntry(dir, '.cc-env')
+
+    const content = await readFile(join(dir, '.gitignore'), 'utf8')
+    expect(content).toBe('.cc-env\n')
+  })
+
+  it('appends entry to existing .gitignore', async () => {
+    const dir = await createTempDir()
+    await mkdir(join(dir, '.git'))
+    await writeFile(join(dir, '.gitignore'), 'node_modules\n', 'utf8')
+
+    await ensureGitignoreEntry(dir, '.cc-env')
+
+    const content = await readFile(join(dir, '.gitignore'), 'utf8')
+    expect(content).toBe('node_modules\n.cc-env\n')
+  })
+
+  it('skips if entry already present', async () => {
+    const dir = await createTempDir()
+    await mkdir(join(dir, '.git'))
+    await writeFile(join(dir, '.gitignore'), 'node_modules\n.cc-env\n', 'utf8')
+
+    await ensureGitignoreEntry(dir, '.cc-env')
+
+    const content = await readFile(join(dir, '.gitignore'), 'utf8')
+    expect(content).toBe('node_modules\n.cc-env\n')
+  })
+
+  it('skips if entry with trailing slash present', async () => {
+    const dir = await createTempDir()
+    await mkdir(join(dir, '.git'))
+    await writeFile(join(dir, '.gitignore'), '.cc-env/\n', 'utf8')
+
+    await ensureGitignoreEntry(dir, '.cc-env')
+
+    const content = await readFile(join(dir, '.gitignore'), 'utf8')
+    expect(content).toBe('.cc-env/\n')
+  })
+
+  it('does nothing outside git repo', async () => {
+    const dir = await createTempDir()
+
+    await ensureGitignoreEntry(dir, '.cc-env')
+
+    await expect(readFile(join(dir, '.gitignore'), 'utf8')).rejects.toThrow()
+  })
+
+  it('handles .gitignore without trailing newline', async () => {
+    const dir = await createTempDir()
+    await mkdir(join(dir, '.git'))
+    await writeFile(join(dir, '.gitignore'), 'node_modules', 'utf8')
+
+    await ensureGitignoreEntry(dir, '.cc-env')
+
+    const content = await readFile(join(dir, '.gitignore'), 'utf8')
+    expect(content).toBe('node_modules\n.cc-env\n')
+  })
+})

package/tests/core/paths.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  resolveClaudeSettingsLocalPath,
+  resolveClaudeSettingsPath,
+  resolveShellConfigPaths,
+} from '../../src/core/paths.js'
+
+describe('Claude home path helpers', () => {
+  it('resolves both Claude settings files under the given home directory', () => {
+    expect(resolveClaudeSettingsPath('/Users/test')).toBe('/Users/test/.claude/settings.json')
+    expect(resolveClaudeSettingsLocalPath('/Users/test')).toBe(
+      '/Users/test/.claude/settings.local.json',
+    )
+  })
+
+  it('resolves zsh, bash, and fish config targets', () => {
+    expect(resolveShellConfigPaths('/Users/test')).toEqual({
+      zsh: '/Users/test/.zshrc',
+      bash: '/Users/test/.bashrc',
+      fish: '/Users/test/.config/fish/config.fish',
+    })
+  })
+})

package/tests/core/schema-mask.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, it } from 'vitest'
+
+import { maskValue, isSensitiveKey } from '../../src/core/mask.js'
+import { envMapSchema, historySchema, presetSchema } from '../../src/core/schema.js'
+
+describe('envMapSchema', () => {
+  it('accepts uppercase flat string maps', () => {
+    const result = envMapSchema.parse({
+      API_URL: 'https://example.com',
+      PORT: '3000',
+      FEATURE_FLAG_1: 'enabled',
+    })
+
+    expect(result).toEqual({
+      API_URL: 'https://example.com',
+      PORT: '3000',
+      FEATURE_FLAG_1: 'enabled',
+    })
+  })
+
+  it('rejects nested values', () => {
+    expect(() => envMapSchema.parse({ NESTED: { NOPE: 'x' } })).toThrow()
+  })
+
+  it('accepts non-object values by stringifying them', () => {
+    const result = envMapSchema.parse({
+      PORT: 3000,
+      ENABLED: true,
+      EMPTY: null,
+    })
+
+    expect(result).toEqual({
+      PORT: '3000',
+      ENABLED: 'true',
+      EMPTY: 'null',
+    })
+  })
+
+  it('rejects lowercase keys', () => {
+    expect(() => envMapSchema.parse({ api_url: 'https://example.com' })).toThrow()
+  })
+})
+
+describe('sensitive masking', () => {
+  it('returns true for ANTHROPIC_AUTH_TOKEN', () => {
+    expect(isSensitiveKey('ANTHROPIC_AUTH_TOKEN')).toBe(true)
+  })
+
+  it('returns true for mixed-case sensitive suffixes', () => {
+    expect(isSensitiveKey('Anthropic_Auth_Token')).toBe(true)
+  })
+
+  it('masks sensitive values', () => {
+    expect(maskValue('ANTHROPIC_AUTH_TOKEN', 'sk-1234567890')).toBe('sk-123456********')
+  })
+
+  it('masks short sensitive values without exposing the original secret', () => {
+    expect(maskValue('ANTHROPIC_AUTH_TOKEN', 'short')).toBe('*****')
+    expect(maskValue('ANTHROPIC_AUTH_TOKEN', '12345678')).toBe('********')
+  })
+
+  it('leaves non-sensitive values unchanged', () => {
+    expect(maskValue('API_URL', 'https://example.com')).toBe('https://example.com')
+  })
+})
+
+describe('historySchema', () => {
+  it('accepts init history with sources and shell writes', () => {
+    const result = historySchema.parse({
+      timestamp: '2026-04-24T12:00:00.000Z',
+      action: 'init',
+      migratedKeys: ['ANTHROPIC_AUTH_TOKEN'],
+      sources: [
+        {
+          file: '/Users/test/.claude/settings.json',
+          backup: {
+            ANTHROPIC_BASE_URL: 'https://settings.example.com',
+          },
+        },
+        {
+          file: '/Users/test/.claude/settings.local.json',
+          backup: {
+            ANTHROPIC_AUTH_TOKEN: 'local-token',
+          },
+        },
+      ],
+      shellWrites: [
+        {
+          shell: 'zsh',
+          filePath: '/Users/test/.zshrc',
+          env: {
+            ANTHROPIC_AUTH_TOKEN: 'local-token',
+          },
+        },
+      ],
+    })
+
+    expect(result).toEqual({
+      timestamp: '2026-04-24T12:00:00.000Z',
+      action: 'init',
+      migratedKeys: ['ANTHROPIC_AUTH_TOKEN'],
+      sources: [
+        {
+          file: '/Users/test/.claude/settings.json',
+          backup: {
+            ANTHROPIC_BASE_URL: 'https://settings.example.com',
+          },
+        },
+        {
+          file: '/Users/test/.claude/settings.local.json',
+          backup: {
+            ANTHROPIC_AUTH_TOKEN: 'local-token',
+          },
+        },
+      ],
+      shellWrites: [
+        {
+          shell: 'zsh',
+          filePath: '/Users/test/.zshrc',
+          env: {
+            ANTHROPIC_AUTH_TOKEN: 'local-token',
+          },
+        },
+      ],
+    })
+  })
+
+  it('rejects init history without migratedKeys', () => {
+    expect(() =>
+      historySchema.parse({
+        timestamp: '2026-04-24T12:00:00.000Z',
+        action: 'init',
+        sources: [
+          {
+            file: '/Users/test/.claude/settings.local.json',
+            backup: {
+              ANTHROPIC_AUTH_TOKEN: 'local-token',
+            },
+          },
+        ],
+        shellWrites: [],
+      }),
+    ).toThrow()
+  })
+})
+
+describe('presetSchema', () => {
+  it('validates a preset object with name, createdAt, updatedAt, and env', () => {
+    const result = presetSchema.parse({
+      name: 'default',
+      createdAt: '2026-04-24T12:00:00.000Z',
+      updatedAt: '2026-04-24T12:30:00.000Z',
+      env: {
+        API_URL: 'https://example.com',
+        ANTHROPIC_AUTH_TOKEN: 'sk-1234567890',
+      },
+    })
+
+    expect(result).toEqual({
+      name: 'default',
+      createdAt: '2026-04-24T12:00:00.000Z',
+      updatedAt: '2026-04-24T12:30:00.000Z',
+      env: {
+        API_URL: 'https://example.com',
+        ANTHROPIC_AUTH_TOKEN: 'sk-1234567890',
+      },
+    })
+  })
+
+  it('rejects invalid ISO datetimes for createdAt and updatedAt', () => {
+    expect(() =>
+      presetSchema.parse({
+        name: 'default',
+        createdAt: 'not-a-date',
+        updatedAt: '2026-04-24',
+        env: {
+          API_URL: 'https://example.com',
+        },
+      }),
+    ).toThrow()
+  })
+})

package/tests/core/spawn.test.ts

@@ -0,0 +1,47 @@
+import { EventEmitter } from 'node:events'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { CliError } from '../../src/core/errors.js'
+
+const spawnMock = vi.fn()
+
+vi.mock('cross-spawn', () => ({
+  default: spawnMock,
+}))
+
+describe('spawnCommand', () => {
+  afterEach(() => {
+    vi.resetModules()
+    vi.clearAllMocks()
+  })
+
+  it('rejects with a CliError when the process closes due to a signal', async () => {
+    const child = new EventEmitter()
+    spawnMock.mockReturnValue(child)
+
+    const { spawnCommand } = await import('../../src/core/spawn.js')
+    const promise = spawnCommand('node', ['script.js'], process.env)
+
+    child.emit('close', null, 'SIGTERM')
+
+    await expect(promise).rejects.toEqual(
+      new CliError('Command terminated by signal SIGTERM'),
+    )
+  })
+
+  it('rejects with a human-readable CliError when the process closes without an exit code or signal', async () => {
+    const child = new EventEmitter()
+    spawnMock.mockReturnValue(child)
+
+    const { spawnCommand } = await import('../../src/core/spawn.js')
+    const promise = spawnCommand('node', ['script.js'], process.env)
+
+    child.emit('close', null, null)
+
+    await expect(promise).rejects.toMatchObject({
+      message: 'Command terminated without an exit code',
+      exitCode: 1,
+    })
+  })
+})

package/tests/flows/init-flow.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  advanceInitFlow,
+  createInitFlowState,
+} from '../../src/flows/init-flow.js'
+
+describe('init flow', () => {
+  it('preselects required keys and does not let them be toggled off', () => {
+    const state = createInitFlowState(
+      ['ANTHROPIC_AUTH_TOKEN', 'EXTRA_KEY'],
+      ['ANTHROPIC_AUTH_TOKEN'],
+    )
+
+    expect(state).toEqual({
+      step: 'keys',
+      availableKeys: ['ANTHROPIC_AUTH_TOKEN', 'EXTRA_KEY'],
+      requiredKeys: ['ANTHROPIC_AUTH_TOKEN'],
+      selectedKeys: ['ANTHROPIC_AUTH_TOKEN'],
+    })
+
+    expect(
+      advanceInitFlow(state, {
+        type: 'toggle-key',
+        key: 'ANTHROPIC_AUTH_TOKEN',
+      }).selectedKeys,
+    ).toEqual(['ANTHROPIC_AUTH_TOKEN'])
+  })
+
+  it('moves directly from key selection to confirm', () => {
+    const state = createInitFlowState(['ANTHROPIC_AUTH_TOKEN'], ['ANTHROPIC_AUTH_TOKEN'])
+
+    expect(advanceInitFlow(state, { type: 'continue' })).toEqual({
+      step: 'confirm',
+      availableKeys: ['ANTHROPIC_AUTH_TOKEN'],
+      requiredKeys: ['ANTHROPIC_AUTH_TOKEN'],
+      selectedKeys: ['ANTHROPIC_AUTH_TOKEN'],
+    })
+  })
+})