@lkangd/cc-env 1.1.2 → 1.2.0

package/dist/cli.js

@@ -5,14 +5,19 @@ import { join } from 'node:path';
 import figlet from 'figlet';
 import gradient from 'gradient-string';
 import { Command } from 'commander';
+import packageJson from '../package.json' with { type: 'json' };
 const h = React.createElement;
 import { createInitCommand } from './commands/init.js';
 import { createPresetCreateCommand } from './commands/preset/create.js';
 import { createDeletePresetCommand } from './commands/preset/delete.js';
+import { createEditPresetCommand } from './commands/preset/edit.js';
+import { createRenamePresetCommand } from './commands/preset/rename.js';
 import { PresetDeleteApp } from './ink/preset-delete-app.js';
+import { PresetEditApp } from './ink/preset-edit-app.js';
 import { createShowPresetsCommand } from './commands/preset/show.js';
 import { createRestoreCommand } from './commands/restore.js';
 import { createRunCommand } from './commands/run.js';
+import { runDoctorCommand } from './commands/doctor.js';
 import { findClaudeExecutable } from './core/find-claude.js';
 import { InitApp } from './ink/init-app.js';
 import { renderEnvSummary } from './ink/summary.js';
@@ -32,7 +37,13 @@ import { createProjectStateService } from './services/project-state-service.js';
 import { createSettingsEnvService } from './services/settings-env-service.js';
 import { createShellEnvService } from './services/shell-env-service.js';
 const program = new Command();
-program.name('cc-env').description('Manage runtime environment variables for Claude Code');
+program
+    .name('cc-env')
+    .description('Manage runtime environment variables for Claude Code')
+    .version(packageJson.version)
+    .option('--verbose', 'Enable verbose output')
+    .option('--quiet', 'Suppress non-essential output')
+    .option('--no-interactive', 'Disable interactive prompts (equivalent to -y)');
 const homeDir = process.env.HOME ?? process.cwd();
 const cwd = process.cwd();
 const settingsPath = join(cwd, 'settings.json');
@@ -111,6 +122,7 @@ program
     .description('Run claude with merged environment variables')
     .option('--dry-run', 'Preview the merged env without executing')
     .option('-y, --yes', 'Auto-select the default preset without interactive prompts')
+    .option('--json', 'Output as JSON (only with --dry-run)')
     .action((args, options) => {
     const rawArgs = args ?? [];
     return createRunCommand({
@@ -136,6 +148,7 @@ program
         args: rawArgs,
         dryRun: options.dryRun ?? false,
         yes: options.yes ?? false,
+        json: options.json ?? false,
         cwd
     });
 });
@@ -186,14 +199,19 @@ program
 program
     .command('show')
     .description('List and view all presets')
-    .action(createShowPresetsCommand({
+    .option('--json', 'Output as JSON')
+    .action((options) => createShowPresetsCommand({
     presetService,
     projectEnvService,
     renderShow: async (presets) => {
+        if (options.json) {
+            process.stdout.write(JSON.stringify(presets, null, 2) + '\n');
+            return;
+        }
         const app = render(h(PresetShowApp, { presets }));
         await app.waitUntilExit();
     }
-}));
+})());
 program
     .command('delete')
     .description('Delete a saved preset')
@@ -235,14 +253,58 @@ program
         return result;
     }
 })({ cwd }));
+program
+    .command('doctor')
+    .description('Check system health and configuration')
+    .option('--json', 'Output as JSON')
+    .action((options) => runDoctorCommand({ cwd, json: options.json }));
+program
+    .command('edit <name>')
+    .description('Edit an existing preset')
+    .action((name) => createEditPresetCommand({
+    presetService,
+    renderEdit: async (preset) => {
+        let result;
+        const app = render(h(PresetEditApp, {
+            name: preset.name,
+            env: preset.env,
+            onSubmit: (value) => {
+                result = value;
+            }
+        }));
+        await app.waitUntilExit();
+        return result;
+    }
+})({ name }));
+program
+    .command('rename <from> <to>')
+    .description('Rename a preset')
+    .action((from, to) => createRenamePresetCommand({ presetService })({ from, to }));
+program
+    .command('completion')
+    .description('Generate shell completion script')
+    .option('--shell <shell>', 'Shell type (bash, zsh, fish)', 'bash')
+    .action(async (options) => {
+    const { generateCompletion } = await import('./commands/completion.js');
+    process.stdout.write(generateCompletion(options.shell));
+});
 function printBanner() {
     const banner = figlet.textSync('CC ENV', { font: 'ANSI Shadow' });
     const line = '─'.repeat(48);
     const styled = gradient(['#00d2ff', '#7b2ff7', '#ff0080'])(banner);
     process.stderr.write(`\n${styled}\x1b[2m\n${line}\x1b[0m\n\n`);
 }
-program.hook('preAction', () => {
-    printBanner();
+program.hook('preAction', (thisCommand) => {
+    const opts = program.opts();
+    if (!opts.quiet)
+        printBanner();
+    // propagate --no-interactive as -y to subcommands
+    const globalOpts = program.opts();
+    if (globalOpts.interactive === false) {
+        const subOpts = thisCommand.opts();
+        if ('yes' in subOpts)
+            thisCommand.setOptionValue('yes', true);
+    }
 });
 program.parseAsync(process.argv).catch((error) => {
     if (error instanceof CliError) {
@@ -252,7 +314,7 @@ program.parseAsync(process.argv).catch((error) => {
     }
     if (error && typeof error === 'object' && 'code' in error) {
         const { code, message } = error;
-        if (code === 'commander.helpDisplayed') {
+        if (code === 'commander.helpDisplayed' || code === 'commander.version') {
             process.exitCode = 0;
             return;
         }

package/dist/commands/completion.js

@@ -0,0 +1,60 @@
+const COMMANDS = ['run', 'init', 'restore', 'show', 'delete', 'create', 'doctor', 'completion', '--help', '--version'];
+export function generateCompletion(shell) {
+    switch (shell) {
+        case 'zsh':
+            return generateZsh();
+        case 'fish':
+            return generateFish();
+        default:
+            return generateBash();
+    }
+}
+function generateBash() {
+    return `# cc-env bash completion
+# Add to ~/.bashrc: eval "$(cc-env completion --shell bash)"
+_cc_env_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local commands="${COMMANDS.join(' ')}"
+  COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+}
+complete -F _cc_env_completions cc-env
+`;
+}
+function generateZsh() {
+    const cmds = COMMANDS.filter((c) => !c.startsWith('-'));
+    const cmdList = cmds.map((c) => `    '${c}'`).join('\n');
+    return `# cc-env zsh completion
+# Add to ~/.zshrc: eval "$(cc-env completion --shell zsh)"
+_cc_env() {
+  local -a commands
+  commands=(
+${cmdList}
+  )
+  _describe 'command' commands
+}
+compdef _cc_env cc-env
+`;
+}
+function generateFish() {
+    const cmds = [
+        ['run', 'Run claude with merged environment variables'],
+        ['init', 'Initialize cc-env for the current project'],
+        ['restore', 'Restore environment variables from a previous snapshot'],
+        ['show', 'List and view all presets'],
+        ['delete', 'Delete a saved preset'],
+        ['create', 'Create a new environment preset'],
+        ['doctor', 'Check system health and configuration'],
+        ['completion', 'Generate shell completion script'],
+    ];
+    const lines = cmds.map(([cmd, desc]) => `complete -c cc-env -f -n '__fish_use_subcommand' -a '${cmd}' -d '${desc}'`);
+    return `# cc-env fish completion
+# Add to fish config: cc-env completion --shell fish | source
+${lines.join('\n')}
+complete -c cc-env -l help -d 'Show help'
+complete -c cc-env -l version -d 'Show version'
+complete -c cc-env -l json -d 'Output as JSON'
+complete -c cc-env -l quiet -d 'Suppress non-essential output'
+complete -c cc-env -l verbose -d 'Enable verbose output'
+complete -c cc-env -l no-interactive -d 'Disable interactive prompts'
+`;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,73 @@
+import { access, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { findClaudeExecutable } from '../core/find-claude.js';
+import { resolveGlobalRoot } from '../core/paths.js';
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkGlobalRoot(globalRoot) {
+    const ok = await exists(globalRoot);
+    return { label: 'Global root (~/.cc-env)', ok, detail: globalRoot };
+}
+async function checkPresetsDir(globalRoot) {
+    const dir = join(globalRoot, 'presets');
+    const ok = await exists(dir);
+    if (!ok)
+        return { label: 'Presets directory', ok: false, detail: dir };
+    const entries = await readdir(dir).catch(() => []);
+    const count = entries.filter((e) => e.endsWith('.json')).length;
+    return { label: 'Presets directory', ok: true, detail: `${dir} (${count} preset${count === 1 ? '' : 's'})` };
+}
+async function checkClaudeExecutable() {
+    try {
+        const path = findClaudeExecutable();
+        return { label: 'Claude executable', ok: true, detail: path };
+    }
+    catch {
+        return { label: 'Claude executable', ok: false, detail: 'not found — run: npm install -g @anthropic-ai/claude-code' };
+    }
+}
+async function checkProjectEnv(cwd) {
+    const path = join(cwd, '.cc-env', 'env.json');
+    const ok = await exists(path);
+    return { label: 'Project env (.cc-env/env.json)', ok, detail: ok ? path : 'not initialized — run: cc-env init' };
+}
+function renderCheck(result, json) {
+    if (json)
+        return '';
+    const icon = result.ok ? '\x1b[32m✔\x1b[0m' : '\x1b[31m✘\x1b[0m';
+    const detail = result.detail ? `\x1b[2m  ${result.detail}\x1b[0m` : '';
+    return `  ${icon}  ${result.label}${detail ? '\n' + detail : ''}`;
+}
+export async function runDoctorCommand({ cwd, json = false, stdout = process.stdout, }) {
+    const globalRoot = resolveGlobalRoot();
+    const checks = await Promise.all([
+        checkGlobalRoot(globalRoot),
+        checkPresetsDir(globalRoot),
+        checkClaudeExecutable(),
+        checkProjectEnv(cwd),
+    ]);
+    if (json) {
+        stdout.write(JSON.stringify(checks, null, 2) + '\n');
+        return;
+    }
+    stdout.write('\n');
+    for (const check of checks) {
+        stdout.write(renderCheck(check, false) + '\n');
+    }
+    stdout.write('\n');
+    const failed = checks.filter((c) => !c.ok);
+    if (failed.length === 0) {
+        stdout.write('  \x1b[32mAll checks passed.\x1b[0m\n\n');
+    }
+    else {
+        stdout.write(`  \x1b[33m${failed.length} check${failed.length > 1 ? 's' : ''} failed.\x1b[0m\n\n`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/preset/edit.js

@@ -1,15 +1,20 @@
-import { spawnSync as defaultSpawnSync } from 'node:child_process';
 import { CliError } from '../../core/errors.js';
-export function createEditPresetCommand({ presetService, processEnv = process.env, spawnSync = defaultSpawnSync, }) {
-    return async function editPreset(name) {
-        const editor = processEnv.EDITOR;
-        if (!editor) {
-            throw new CliError('EDITOR is required to edit a preset');
-        }
-        const preset = await presetService.read(name);
-        const result = spawnSync(editor, [preset.filePath], { stdio: 'inherit' });
-        if (result.status !== 0) {
-            throw new CliError(`Editor exited with code ${result.status ?? 1}`);
+export function createEditPresetCommand({ presetService, renderEdit, }) {
+    return async function editPreset({ name }) {
+        if (!name)
+            throw new CliError('Usage: cc-env edit <preset-name>');
+        const existing = await presetService.read(name);
+        const result = await renderEdit({ name, env: existing.env });
+        if (!result?.confirmed) {
+            process.stdout.write('Edit cancelled.\n');
+            return;
         }
+        await presetService.write({
+            name,
+            env: result.env,
+            createdAt: existing.createdAt,
+            updatedAt: new Date().toISOString(),
+        });
+        process.stdout.write(`Updated preset "${name}"\n`);
     };
 }

package/dist/commands/preset/rename.js

@@ -0,0 +1,16 @@
+import { CliError } from '../../core/errors.js';
+export function createRenamePresetCommand({ presetService }) {
+    return async function renamePreset({ from, to }) {
+        if (!from || !to)
+            throw new CliError('Usage: cc-env rename <from> <to>');
+        if (from === to)
+            throw new CliError('New name must be different from the current name');
+        const existing = await presetService.read(from);
+        const names = await presetService.listNames();
+        if (names.includes(to))
+            throw new CliError(`Preset "${to}" already exists`);
+        await presetService.write({ ...existing, name: to, updatedAt: new Date().toISOString() });
+        await presetService.remove(from);
+        process.stdout.write(`Renamed preset "${from}" → "${to}"\n`);
+    };
+}

package/dist/commands/run.js

@@ -9,7 +9,7 @@ const requiredInitKeys = [
     'ANTHROPIC_REASONING_MODEL',
 ];
 export function createRunCommand({ claudeSettingsEnvService, presetService, projectEnvService, projectStateService, findClaude, renderPresetSelect, spawnCommand, stdout = process.stdout, }) {
-    return async function run({ args = [], dryRun = false, yes = false, cwd, }) {
+    return async function run({ args = [], dryRun = false, yes = false, json = false, cwd, }) {
         // Step 0: Check settings files for init-managed keys
         const sources = await claudeSettingsEnvService.read();
         const mergedSettingsEnv = sources.reduce((acc, s) => ({ ...acc, ...s.env }), {});
@@ -66,6 +66,14 @@ export function createRunCommand({ claudeSettingsEnvService, presetService, proj
             claudeArgs = args;
         }
         // Step 6: Print env vars
+        if (json && dryRun) {
+            stdout.write(JSON.stringify({
+                preset: { name: selected.name, source: selected.source },
+                command: [command, ...claudeArgs],
+                env: selected.env
+            }, null, 2) + '\n');
+            return;
+        }
         const presetKeys = new Set(Object.keys(selected.env));
         const envBlock = formatRunEnvBlock(selected.env, presetKeys);
         stdout.write(`Using preset: ${selected.name} (${selected.source})\n${envBlock}\n\n`);

package/dist/ink/preset-edit-app.js

@@ -0,0 +1,112 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+export function PresetEditApp({ name, env: initialEnv, onSubmit }) {
+    const { exit } = useApp();
+    const [entries, setEntries] = useState(Object.entries(initialEnv));
+    const [cursor, setCursor] = useState(0);
+    const [editing, setEditing] = useState(null);
+    const [textInput, setTextInput] = useState('');
+    const [error, setError] = useState();
+    const [step, setStep] = useState('list');
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            if (editing !== null) {
+                setEditing(null);
+                setTextInput('');
+                setError(undefined);
+                return;
+            }
+            onSubmit({ env: initialEnv, confirmed: false });
+            exit();
+            return;
+        }
+        if (step === 'list' && editing === null) {
+            if (key.upArrow || input === 'k') {
+                setCursor((c) => Math.max(0, c - 1));
+                return;
+            }
+            if (key.downArrow || input === 'j') {
+                setCursor((c) => Math.min(entries.length - 1, c + 1));
+                return;
+            }
+            if (key.return && entries.length > 0) {
+                const entry = entries[cursor];
+                if (entry) {
+                    setTextInput(`${entry[0]}=${entry[1]}`);
+                    setEditing(cursor);
+                    setError(undefined);
+                }
+                return;
+            }
+            if (input === 'd' && entries.length > 0) {
+                setEntries((prev) => prev.filter((_, i) => i !== cursor));
+                setCursor((c) => Math.max(0, c - 1));
+                return;
+            }
+            if (input === 'a') {
+                setTextInput('');
+                setEditing(entries.length);
+                setError(undefined);
+                return;
+            }
+            if (input === 's') {
+                setStep('confirm');
+                return;
+            }
+        }
+        if (editing !== null) {
+            if (key.backspace || key.delete) {
+                setTextInput((v) => v.slice(0, -1));
+                return;
+            }
+            if (key.return) {
+                const sep = textInput.indexOf('=');
+                if (sep <= 0) {
+                    setError('Format must be KEY=VALUE');
+                    return;
+                }
+                const k = textInput.slice(0, sep);
+                const v = textInput.slice(sep + 1);
+                if (!/^[A-Z0-9_]+$/.test(k)) {
+                    setError('Key must match [A-Z0-9_]+');
+                    return;
+                }
+                setEntries((prev) => {
+                    const next = [...prev];
+                    if (editing < prev.length) {
+                        next[editing] = [k, v];
+                    }
+                    else {
+                        next.push([k, v]);
+                    }
+                    return next;
+                });
+                setEditing(null);
+                setTextInput('');
+                setError(undefined);
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setTextInput((v) => v + input);
+                return;
+            }
+        }
+        if (step === 'confirm') {
+            if (key.return) {
+                const env = Object.fromEntries(entries);
+                onSubmit({ env, confirmed: true });
+                exit();
+                return;
+            }
+            if (input === 'q') {
+                setStep('list');
+                return;
+            }
+        }
+    });
+    if (step === 'confirm') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Save changes to preset \"", name, "\"?"] }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: entries.map(([k, v]) => (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "\u2022 " }), _jsx(Text, { color: "magenta", children: k }), _jsx(Text, { dimColor: true, children: "=" }), _jsx(Text, { children: v })] }, k))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press enter to confirm \u00B7 q to go back" }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Editing preset: ", name] }), _jsx(Text, { dimColor: true, children: "\u2191/k \u2193/j navigate \u00B7 enter edit \u00B7 d delete \u00B7 a add \u00B7 s save \u00B7 q cancel" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [entries.map(([k, v], i) => (_jsxs(Box, { children: [_jsx(Text, { children: i === cursor ? '❯ ' : '  ' }), _jsx(Text, { color: "magenta", children: k }), _jsx(Text, { dimColor: true, children: "=" }), _jsx(Text, { children: v })] }, k))), entries.length === 0 && _jsx(Text, { dimColor: true, children: "No entries. Press a to add." })] }), editing !== null && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: editing < entries.length ? 'Edit entry' : 'Add entry' }), _jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: ['>', " "] }), _jsx(Text, { color: "cyan", children: textInput }), _jsx(Text, { dimColor: true, children: "\u2588" })] }), error ? _jsx(Text, { color: "red", children: error }) : null] }))] }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lkangd/cc-env",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "",
   "homepage": "https://github.com/lkangd/cc-env#readme",
   "bugs": {
@@ -32,7 +32,8 @@
     "build": "tsc -p tsconfig.build.json",
     "prepack": "npm run build",
     "dev": "tsx src/cli.ts",
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "@inkjs/ui": "^2.0.0",
@@ -53,6 +54,7 @@
     "@types/gradient-string": "^1.1.6",
     "@types/node": "^20.19.0",
     "@types/react": "^19.1.10",
+    "@vitest/coverage-v8": "^3.2.4",
     "execa": "^9.6.0",
     "react-test-renderer": "^19.2.5",
     "tsx": "^4.20.3",