@lkangd/cc-env 1.0.0

package/.claude/settings.json

@@ -0,0 +1,6 @@
+{
+  "enabledPlugins": {
+    "superpowers@claude-plugins-official": true
+  },
+  "env": {}
+}

package/.claude/settings.local.json

@@ -0,0 +1,3 @@
+{
+  "env": {}
+}

package/.nvmrc

@@ -0,0 +1 @@
+20.19.2

package/dist/cli.js

@@ -0,0 +1,266 @@
+import React from 'react';
+import { render } from 'ink';
+import { join } from 'node:path';
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import { Command } from 'commander';
+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 { PresetDeleteApp } from './ink/preset-delete-app.js';
+import { createShowPresetsCommand } from './commands/preset/show.js';
+import { createRestoreCommand } from './commands/restore.js';
+import { createRunCommand } from './commands/run.js';
+import { findClaudeExecutable } from './core/find-claude.js';
+import { InitApp } from './ink/init-app.js';
+import { renderEnvSummary } from './ink/summary.js';
+import { PresetCreateApp } from './ink/preset-create-app.js';
+import { PresetShowApp } from './ink/preset-show-app.js';
+import { RunPresetSelectApp } from './ink/run-preset-select-app.js';
+import { advanceRestoreFlow, createRestoreFlowState } from './flows/restore-flow.js';
+import { RestoreApp } from './ink/restore-app.js';
+import { CliError } from './core/errors.js';
+import { resolveGlobalRoot } from './core/paths.js';
+import { spawnCommand } from './core/spawn.js';
+import { createClaudeSettingsEnvService } from './services/claude-settings-env-service.js';
+import { createHistoryService } from './services/history-service.js';
+import { createPresetService } from './services/preset-service.js';
+import { createProjectEnvService } from './services/project-env-service.js';
+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');
+const homeDir = process.env.HOME ?? process.cwd();
+const cwd = process.cwd();
+const settingsPath = join(cwd, 'settings.json');
+const globalRoot = resolveGlobalRoot();
+const claudeSettingsEnvService = createClaudeSettingsEnvService({ homeDir, cwd });
+const settingsEnvService = createSettingsEnvService({ settingsPath });
+const shellEnvService = createShellEnvService({ homeDir });
+const projectEnvService = createProjectEnvService({ cwd });
+const presetService = createPresetService(globalRoot);
+const historyService = createHistoryService(globalRoot);
+async function runRestoreFlow(context) {
+    const state = createRestoreFlowState(context.records);
+    const firstRecord = context.records[0];
+    if (!firstRecord) {
+        render(h(RestoreApp, { state }));
+        return undefined;
+    }
+    if (context.yes) {
+        const selectedRecordState = advanceRestoreFlow(state, {
+            type: 'select-record',
+            timestamp: firstRecord.timestamp
+        });
+        if (firstRecord.action === 'init') {
+            const doneState = advanceRestoreFlow(selectedRecordState, { type: 'confirm' });
+            if (doneState.step !== 'done') {
+                return undefined;
+            }
+            return {
+                confirmed: true,
+                timestamp: firstRecord.timestamp
+            };
+        }
+        const confirmState = advanceRestoreFlow(selectedRecordState, {
+            type: 'select-target',
+            targetType: firstRecord.targetType,
+            ...(firstRecord.targetType === 'preset' ? { targetName: firstRecord.targetName } : {})
+        });
+        const doneState = advanceRestoreFlow(confirmState, { type: 'confirm' });
+        if (doneState.step === 'done' && doneState.targetType === 'preset') {
+            return {
+                confirmed: true,
+                timestamp: doneState.selectedTimestamp,
+                targetType: doneState.targetType,
+                targetName: doneState.targetName
+            };
+        }
+        if (doneState.step === 'done') {
+            return {
+                confirmed: true,
+                timestamp: doneState.selectedTimestamp,
+                targetType: doneState.targetType
+            };
+        }
+        return undefined;
+    }
+    let result;
+    const app = render(h(RestoreApp, {
+        state,
+        onSubmit: value => {
+            result = value;
+        }
+    }));
+    await app.waitUntilExit();
+    return result;
+}
+program.exitOverride().configureOutput({
+    writeErr: str => {
+        if (!str.startsWith('error:')) {
+            process.stderr.write(str);
+        }
+    }
+});
+program
+    .command('run [args...]')
+    .allowUnknownOption(true)
+    .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')
+    .action((args, options) => {
+    const rawArgs = args ?? [];
+    return createRunCommand({
+        claudeSettingsEnvService,
+        presetService,
+        projectEnvService,
+        projectStateService: createProjectStateService(globalRoot),
+        findClaude: findClaudeExecutable,
+        renderPresetSelect: async ({ presets, defaultIndex }) => {
+            let result;
+            const app = render(h(RunPresetSelectApp, {
+                presets,
+                defaultIndex,
+                onSubmit: preset => {
+                    result = preset;
+                }
+            }));
+            await app.waitUntilExit();
+            return result;
+        },
+        spawnCommand
+    })({
+        args: rawArgs,
+        dryRun: options.dryRun ?? false,
+        yes: options.yes ?? false,
+        cwd
+    });
+});
+program
+    .command('init')
+    .description('Initialize cc-env for the current project')
+    .option('-y, --yes', 'Accept all defaults without interactive prompts')
+    .action(options => createInitCommand({
+    claudeSettingsEnvService,
+    shellEnvService,
+    historyService,
+    renderEnvSummary,
+    renderFlow: async (context) => {
+        if (context.yes) {
+            return {
+                selectedKeys: context.requiredKeys,
+                confirmed: true
+            };
+        }
+        let result;
+        const app = render(h(InitApp, {
+            ...context,
+            onSubmit: value => {
+                result = value;
+            }
+        }));
+        await app.waitUntilExit();
+        return result;
+    }
+})({
+    yes: options.yes
+}));
+program
+    .command('restore')
+    .description('Restore environment variables from a previous snapshot')
+    .option('-y, --yes', 'Accept all defaults without interactive prompts')
+    .action(options => createRestoreCommand({
+    historyService,
+    claudeSettingsEnvService,
+    shellEnvService,
+    settingsEnvService,
+    presetService,
+    renderEnvSummary: renderEnvSummary,
+    renderFlow: context => runRestoreFlow(context)
+})({
+    yes: options.yes
+}));
+const presetCommand = program.command('preset').description('Manage environment presets');
+presetCommand
+    .command('show')
+    .description('List and view all presets')
+    .action(createShowPresetsCommand({
+    presetService,
+    projectEnvService,
+    renderShow: async (presets) => {
+        const app = render(h(PresetShowApp, { presets }));
+        await app.waitUntilExit();
+    }
+}));
+presetCommand
+    .command('delete')
+    .description('Delete a saved preset')
+    .action(createDeletePresetCommand({
+    presetService,
+    projectEnvService,
+    renderDelete: async (presets) => {
+        let result;
+        const app = render(h(PresetDeleteApp, {
+            presets,
+            onSubmit: preset => {
+                result = preset;
+            }
+        }));
+        await app.waitUntilExit();
+        return result;
+    }
+}));
+presetCommand
+    .command('create')
+    .description('Create a new environment preset')
+    .action(() => createPresetCreateCommand({
+    presetService,
+    projectEnvService,
+    renderFlow: async () => {
+        let result;
+        const app = render(h(PresetCreateApp, {
+            onSubmit: value => {
+                result = value;
+            },
+            readFile: async (filePath) => {
+                const { readEnvFile } = await import('./commands/preset/create.js');
+                return readEnvFile(filePath);
+            },
+            globalPresetPath: name => presetService.getPath(name),
+            projectEnvPath: join(cwd, '.cc-env', 'env.json')
+        }));
+        await app.waitUntilExit();
+        return result;
+    }
+})({ cwd }));
+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.parseAsync(process.argv).catch((error) => {
+    if (error instanceof CliError) {
+        process.stderr.write(`\n  Error: ${error.message}\n\n`);
+        process.exitCode = error.exitCode;
+        return;
+    }
+    if (error && typeof error === 'object' && 'code' in error) {
+        const { code, message } = error;
+        if (code === 'commander.helpDisplayed') {
+            process.exitCode = 0;
+            return;
+        }
+        const hint = `  Run "cc-env --help" to see available commands and options.\n`;
+        const formatted = message?.replace(/^error:\s*/i, '') ?? 'Unknown error';
+        process.stderr.write(`\n  Error: ${formatted}\n\n${hint}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    throw error;
+});

package/dist/commands/debug.js

@@ -0,0 +1,17 @@
+import { toProcessEnvMap } from '../core/process-env.js';
+import { renderEnvSummary } from '../ink/summary.js';
+export function createDebugCommand({ projectEnvService, processEnv }) {
+    return async function debug() {
+        const projectEnv = await projectEnvService.read();
+        await renderEnvSummary({
+            title: 'Process Environment',
+            description: 'Current process environment variables',
+            env: toProcessEnvMap(processEnv)
+        });
+        await renderEnvSummary({
+            title: 'Project Environment',
+            description: 'Environment variables from .cc-env/env.json',
+            env: projectEnv
+        });
+    };
+}

package/dist/commands/init.js

@@ -0,0 +1,64 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { CliError } from '../core/errors.js';
+import { envMapSchema } from '../core/schema.js';
+const h = React.createElement;
+const requiredInitKeys = [
+    'ANTHROPIC_AUTH_TOKEN',
+    'ANTHROPIC_BASE_URL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    'ANTHROPIC_REASONING_MODEL',
+];
+function omitKeys(env, keys) {
+    return envMapSchema.parse(Object.fromEntries(Object.entries(env).filter(([key]) => !keys.includes(key))));
+}
+export function createInitCommand({ claudeSettingsEnvService, shellEnvService, historyService, renderFlow, renderEnvSummary, }) {
+    return async function init({ yes = false } = {}) {
+        const sources = await claudeSettingsEnvService.read();
+        if (sources.every((s) => !s.exists)) {
+            throw new CliError('No Claude settings files were found');
+        }
+        const effectiveEnv = envMapSchema.parse(sources.reduce((acc, source) => ({ ...acc, ...source.env }), {}));
+        const keys = Object.keys(effectiveEnv).sort();
+        const requiredKeys = requiredInitKeys.filter((key) => key in effectiveEnv);
+        const sourceFiles = sources.map((s) => s.path);
+        const result = await renderFlow({ keys, requiredKeys, yes, sourceFiles });
+        if (!result?.confirmed) {
+            return;
+        }
+        const migratedEnv = envMapSchema.parse(Object.fromEntries(result.selectedKeys
+            .filter((key) => key in effectiveEnv)
+            .map((key) => [key, effectiveEnv[key]])));
+        if (Object.keys(migratedEnv).length === 0) {
+            throw new CliError('No selected env values found to migrate');
+        }
+        const initSources = sources.map((source) => ({
+            file: source.path,
+            backup: envMapSchema.parse(Object.fromEntries(result.selectedKeys
+                .filter((key) => key in source.env)
+                .map((key) => [key, source.env[key]]))),
+        }));
+        const timestamp = new Date().toISOString();
+        const shellWrites = await shellEnvService.write(migratedEnv);
+        await historyService.write({
+            timestamp,
+            action: 'init',
+            migratedKeys: result.selectedKeys,
+            sources: initSources,
+            shellWrites,
+        });
+        await claudeSettingsEnvService.write(sources.map((source) => ({
+            path: source.path,
+            env: omitKeys(source.env, result.selectedKeys),
+        })));
+        await renderEnvSummary({
+            title: 'Migrated',
+            env: migratedEnv,
+            fromFiles: initSources.map((s) => s.file),
+            toFiles: shellWrites.map((sw) => sw.filePath),
+            footer: h(Box, { flexDirection: 'column' }, h(Text, { color: 'green' }, 'Init complete'), h(Text, { bold: true, color: 'green' }, 'Please restart your terminal for the migrated environment variables to take effect.')),
+        });
+    };
+}

package/dist/commands/preset/create.js

@@ -0,0 +1,61 @@
+import { readFile } from 'node:fs/promises';
+import { extname } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { CliError } from '../../core/errors.js';
+import { ensureGitignoreEntry } from '../../core/gitignore.js';
+import { toProcessEnvMap } from '../../core/process-env.js';
+export async function readEnvFile(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        const extension = extname(filePath).toLowerCase();
+        if (extension !== '.yaml' && extension !== '.yml' && extension !== '.json') {
+            throw new CliError(`Unsupported file format: ${extension}`, 2);
+        }
+        const parsed = extension === '.yaml' || extension === '.yml'
+            ? parseYaml(content)
+            : JSON.parse(content);
+        const raw = (parsed ?? {});
+        const source = extension === '.json'
+            && raw
+            && typeof raw === 'object'
+            && 'env' in raw
+            && raw.env
+            && typeof raw.env === 'object'
+            && !Array.isArray(raw.env)
+            ? raw.env
+            : raw;
+        const env = toProcessEnvMap(source);
+        return {
+            allKeys: Object.keys(env),
+            env,
+        };
+    }
+    catch (error) {
+        if (error instanceof CliError)
+            throw error;
+        throw new CliError(`Failed to read env file: ${filePath}`, 2);
+    }
+}
+export function createPresetCreateCommand({ presetService, projectEnvService, renderFlow, ensureGitignore = (dir, entry) => ensureGitignoreEntry(dir, entry), }) {
+    return async function createPreset({ cwd }) {
+        const result = await renderFlow();
+        if (!result)
+            return;
+        const selectedEnv = {};
+        for (const key of result.selectedKeys) {
+            selectedEnv[key] = result.env[key] ?? '';
+        }
+        const timestamp = new Date().toISOString();
+        if (result.destination === 'project') {
+            await projectEnvService.write(selectedEnv, { name: result.presetName, createdAt: timestamp, updatedAt: timestamp });
+            await ensureGitignore(cwd, '.cc-env');
+            return;
+        }
+        await presetService.write({
+            name: result.presetName,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            env: selectedEnv,
+        });
+    };
+}

package/dist/commands/preset/delete.js

@@ -0,0 +1,25 @@
+export function createDeletePresetCommand({ presetService, projectEnvService, renderDelete, }) {
+    return async function deletePreset() {
+        const names = await presetService.listNames();
+        const globalPresets = await Promise.all(names.map((name) => presetService.read(name).then((p) => ({ name, env: p.env, source: 'global' }))));
+        const { env: projectEnv, name: projectName } = await projectEnvService.readWithMeta();
+        const projectPreset = Object.keys(projectEnv).length > 0
+            ? [{ name: projectName ?? 'project', env: projectEnv, source: 'project' }]
+            : [];
+        const presets = [...projectPreset, ...globalPresets];
+        if (presets.length === 0) {
+            console.log('No presets found.');
+            return;
+        }
+        const selected = await renderDelete(presets);
+        if (!selected)
+            return;
+        if (selected.source === 'project') {
+            await projectEnvService.write({});
+        }
+        else {
+            await presetService.remove(selected.name);
+        }
+        console.log(`Deleted preset: ${selected.name}`);
+    };
+}

package/dist/commands/preset/edit.js

@@ -0,0 +1,15 @@
+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}`);
+        }
+    };
+}

package/dist/commands/preset/list.js

@@ -0,0 +1,16 @@
+export function createListPresetsCommand({ presetService, projectEnvService, renderList, }) {
+    return async function listPresets() {
+        const names = await presetService.listNames();
+        const globalPresets = await Promise.all(names.map((name) => presetService.read(name).then((p) => ({ name, env: p.env, source: 'global' }))));
+        const { env: projectEnv, name: projectName } = await projectEnvService.readWithMeta();
+        const projectPreset = Object.keys(projectEnv).length > 0
+            ? [{ name: projectName ?? 'project', env: projectEnv, source: 'project' }]
+            : [];
+        const presets = [...projectPreset, ...globalPresets];
+        if (presets.length === 0) {
+            console.log('No presets found.');
+            return;
+        }
+        await renderList(presets);
+    };
+}

package/dist/commands/preset/show.js

@@ -0,0 +1,16 @@
+export function createShowPresetsCommand({ presetService, projectEnvService, renderShow, }) {
+    return async function showPresets() {
+        const names = await presetService.listNames();
+        const globalPresets = await Promise.all(names.map((name) => presetService.read(name).then((p) => ({ name, env: p.env, source: 'global' }))));
+        const { env: projectEnv, name: projectName } = await projectEnvService.readWithMeta();
+        const projectPreset = Object.keys(projectEnv).length > 0
+            ? [{ name: projectName ?? 'project', env: projectEnv, source: 'project' }]
+            : [];
+        const presets = [...projectPreset, ...globalPresets];
+        if (presets.length === 0) {
+            console.log('No presets found.');
+            return;
+        }
+        await renderShow(presets);
+    };
+}

package/dist/commands/restore.js

@@ -0,0 +1,65 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { CliError } from '../core/errors.js';
+const h = React.createElement;
+export function createRestoreCommand({ historyService, claudeSettingsEnvService, shellEnvService, settingsEnvService, presetService, renderFlow, renderEnvSummary, }) {
+    return async function restore({ yes = false } = {}) {
+        const records = await historyService.list();
+        const result = await renderFlow({ records, yes });
+        if (!result?.confirmed) {
+            return;
+        }
+        const record = records.find((entry) => entry.timestamp === result.timestamp);
+        if (!record) {
+            throw new CliError('Restore record not found');
+        }
+        if (record.action === 'init') {
+            const mergedBackup = Object.fromEntries(record.sources.flatMap((s) => Object.entries(s.backup)));
+            const current = await claudeSettingsEnvService.read();
+            await shellEnvService.removeKeys(record.shellWrites, record.migratedKeys);
+            await claudeSettingsEnvService.write(current.map((source) => ({
+                path: source.path,
+                env: {
+                    ...source.env,
+                    ...(record.sources.find((s) => s.file === source.path)?.backup ?? {}),
+                },
+            })));
+            await renderEnvSummary({
+                title: 'Restored',
+                env: mergedBackup,
+                fromFiles: record.shellWrites.map((sw) => sw.filePath),
+                toFiles: record.sources.map((s) => s.file),
+                footer: h(Box, { flexDirection: 'column' }, h(Text, { color: 'green' }, 'Restore complete'), h(Text, { bold: true, color: 'green' }, 'Please restart your terminal for the restored environment variables to take effect.')),
+            });
+            return;
+        }
+        if (result.targetType === 'settings') {
+            const currentSettings = await settingsEnvService.read();
+            await settingsEnvService.write({
+                ...currentSettings,
+                ...record.backup,
+            });
+            await renderEnvSummary({
+                title: 'Restored to settings',
+                env: record.backup,
+                footer: h(Box, { flexDirection: 'column' }, h(Text, { color: 'green' }, 'Restore complete'), h(Text, { bold: true, color: 'green' }, 'Please restart your terminal for the restored environment variables to take effect.')),
+            });
+            return;
+        }
+        const presetName = result.targetName ?? record.targetName;
+        const preset = await presetService.read(presetName);
+        await presetService.write({
+            ...preset,
+            updatedAt: new Date().toISOString(),
+            env: {
+                ...preset.env,
+                ...record.backup,
+            },
+        });
+        await renderEnvSummary({
+            title: `Restored to preset ${presetName}`,
+            env: record.backup,
+            footer: h(Box, { flexDirection: 'column' }, h(Text, { color: 'green' }, 'Restore complete'), h(Text, { bold: true, color: 'green' }, 'Please restart your terminal for the restored environment variables to take effect.')),
+        });
+    };
+}

package/dist/commands/run.js

@@ -0,0 +1,80 @@
+import { CliError } from '../core/errors.js';
+import { formatRunEnvBlock } from '../core/format.js';
+const requiredInitKeys = [
+    'ANTHROPIC_AUTH_TOKEN',
+    'ANTHROPIC_BASE_URL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    '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, }) {
+        // Step 0: Check settings files for init-managed keys
+        const sources = await claudeSettingsEnvService.read();
+        const mergedSettingsEnv = sources.reduce((acc, s) => ({ ...acc, ...s.env }), {});
+        const staleKeys = requiredInitKeys.filter((k) => k in mergedSettingsEnv);
+        if (staleKeys.length > 0) {
+            throw new CliError(`Found init-managed keys in Claude settings:\n\n  ${staleKeys.join(', \n  ')}. \n\n  Run "cc-env init" first.`);
+        }
+        // Step 1: Collect all presets (project + global)
+        const names = await presetService.listNames();
+        const globalPresets = await Promise.all(names.map((name) => presetService.read(name).then((p) => ({ name, env: p.env, source: 'global' }))));
+        const { env: projectEnv, name: projectName } = await projectEnvService.readWithMeta();
+        const projectPreset = Object.keys(projectEnv).length > 0
+            ? [{ name: projectName ?? 'project', env: projectEnv, source: 'project' }]
+            : [];
+        const presets = [...projectPreset, ...globalPresets];
+        if (presets.length === 0) {
+            throw new CliError('No presets found. Create one with "cc-env preset create".');
+        }
+        // Step 2: Determine default selection
+        const savedRef = await projectStateService.getLastPreset(cwd);
+        let defaultIndex = 0;
+        if (savedRef) {
+            const idx = presets.findIndex((p) => p.name === savedRef.presetName && p.source === savedRef.source);
+            if (idx >= 0)
+                defaultIndex = idx;
+        }
+        else if (projectPreset.length > 0) {
+            defaultIndex = 0;
+        }
+        // Step 3: Select preset (interactive or auto)
+        let selected;
+        if (yes) {
+            selected = presets[defaultIndex];
+        }
+        else {
+            selected = await renderPresetSelect({ presets, defaultIndex });
+        }
+        if (!selected)
+            return;
+        // Step 4: Save selection
+        await projectStateService.saveLastPreset(cwd, {
+            presetName: selected.name,
+            source: selected.source,
+        });
+        // Step 5: Resolve claude command
+        let command;
+        let claudeArgs;
+        if (args.length > 0 && args[0] === 'claude') {
+            command = 'claude';
+            claudeArgs = args.slice(1);
+        }
+        else {
+            command = findClaude();
+            claudeArgs = args;
+        }
+        // Step 6: Print env vars
+        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`);
+        if (dryRun) {
+            const preview = [command, ...claudeArgs].join(' ');
+            stdout.write(`Would run: ${preview}\n`);
+            return;
+        }
+        // Step 7: Spawn
+        await spawnCommand(command, claudeArgs, { ...process.env, ...selected.env });
+    };
+}

package/dist/core/errors.js

@@ -0,0 +1,11 @@
+export class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = 'CliError';
+        this.exitCode = exitCode;
+    }
+}
+export function invalidUsage(message) {
+    return new CliError(message, 2);
+}