@lkangd/cc-env 1.1.1 → 1.1.2

package/tests/commands/run.test.ts

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

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

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

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

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

@@ -1,40 +0,0 @@
-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'],
-    })
-  })
-})