@lkangd/cc-env 1.2.1 → 1.3.0

package/dist/cli.js

@@ -7,7 +7,6 @@ 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';
@@ -19,7 +18,6 @@ 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';
 import { PresetCreateApp } from './ink/preset-create-app.js';
 import { PresetShowApp } from './ink/preset-show-app.js';
@@ -54,8 +52,80 @@ const shellEnvService = createShellEnvService({ homeDir });
 const projectEnvService = createProjectEnvService({ cwd });
 const presetService = createPresetService(globalRoot);
 const historyService = createHistoryService(globalRoot);
+const projectStateService = createProjectStateService(globalRoot);
+async function runPresetCreateFlow({ detectedEnv, requiredKeys }) {
+    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'),
+        detectedEnv,
+        requiredKeys,
+    }));
+    await app.waitUntilExit();
+    return result;
+}
+async function runWithBootstrap({ args = [], dryRun = false, yes = false, json = false, skipDetect = false, }) {
+    const result = await createRunCommand({
+        claudeSettingsEnvService,
+        presetService,
+        projectEnvService,
+        projectStateService,
+        findClaude: findClaudeExecutable,
+        renderPresetSelect: async ({ presets, defaultIndex }) => {
+            let selected;
+            const app = render(h(RunPresetSelectApp, {
+                presets,
+                defaultIndex,
+                onSubmit: preset => {
+                    selected = preset;
+                }
+            }));
+            await app.waitUntilExit();
+            return selected;
+        },
+        spawnCommand
+    })({
+        args,
+        dryRun,
+        yes,
+        json,
+        skipDetect,
+        cwd,
+    });
+    if (!result || result.status === 'executed') {
+        return;
+    }
+    if (Object.keys(result.detectedEnv).length === 0) {
+        throw new CliError('No presets found and no migratable Claude settings were detected.');
+    }
+    const createdPreset = await createPresetCreateCommand({
+        presetService,
+        projectEnvService,
+        claudeSettingsEnvService,
+        historyService,
+        renderFlow: runPresetCreateFlow,
+    })({ cwd });
+    if (!createdPreset) {
+        return;
+    }
+    await projectStateService.saveLastPreset(cwd, createdPreset);
+    await runWithBootstrap({
+        args,
+        dryRun,
+        yes: true,
+        json,
+        skipDetect: true,
+    });
+}
 async function runRestoreFlow(context) {
-    const state = createRestoreFlowState(context.records);
+    const state = createRestoreFlowState(context.records, cwd);
     const firstRecord = context.records[0];
     if (!firstRecord) {
         render(h(RestoreApp, { state }));
@@ -66,16 +136,19 @@ async function runRestoreFlow(context) {
             type: 'select-record',
             timestamp: firstRecord.timestamp
         });
-        if (firstRecord.action === 'init') {
+        if (firstRecord.action === 'init' || firstRecord.action === 'preset-create') {
             const doneState = advanceRestoreFlow(selectedRecordState, { type: 'confirm' });
             if (doneState.step !== 'done') {
                 return undefined;
             }
             return {
                 confirmed: true,
-                timestamp: firstRecord.timestamp
+                timestamp: firstRecord.timestamp,
             };
         }
+        if (firstRecord.action !== 'restore') {
+            return undefined;
+        }
         const confirmState = advanceRestoreFlow(selectedRecordState, {
             type: 'select-target',
             targetType: firstRecord.targetType,
@@ -94,7 +167,7 @@ async function runRestoreFlow(context) {
             return {
                 confirmed: true,
                 timestamp: doneState.selectedTimestamp,
-                targetType: doneState.targetType
+                ...(doneState.targetType ? { targetType: doneState.targetType } : {}),
             };
         }
         return undefined;
@@ -125,62 +198,13 @@ program
     .option('--json', 'Output as JSON (only with --dry-run)')
     .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
-    })({
+    return runWithBootstrap({
         args: rawArgs,
         dryRun: options.dryRun ?? false,
         yes: options.yes ?? false,
         json: options.json ?? 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')
@@ -233,26 +257,15 @@ program
 program
     .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 }));
+    .action(async () => {
+    await createPresetCreateCommand({
+        presetService,
+        projectEnvService,
+        claudeSettingsEnvService,
+        historyService,
+        renderFlow: runPresetCreateFlow,
+    })({ cwd });
+});
 program
     .command('doctor')
     .description('Check system health and configuration')
@@ -306,7 +319,22 @@ program.hook('preAction', (thisCommand) => {
             thisCommand.setOptionValue('yes', true);
     }
 });
-program.parseAsync(process.argv).catch((error) => {
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        const hasGlobalPreset = (await presetService.listNames()).length > 0;
+        const { env: projectEnv } = await projectEnvService.readWithMeta();
+        if (hasGlobalPreset || Object.keys(projectEnv).length > 0) {
+            await runWithBootstrap({ args: [], yes: !process.stdin.isTTY });
+            return;
+        }
+        program.outputHelp();
+        process.exitCode = 0;
+        return;
+    }
+    await program.parseAsync(process.argv);
+}
+main().catch((error) => {
     if (error instanceof CliError) {
         process.stderr.write(`\n  Error: ${error.message}\n\n`);
         process.exitCode = error.exitCode;

package/dist/commands/init.js

@@ -1,16 +1,9 @@
 import React from 'react';
 import { Box, Text } from 'ink';
+import { requiredClaudeKeys } from '../core/claude-required-keys.js';
 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))));
 }
@@ -22,7 +15,7 @@ export function createInitCommand({ claudeSettingsEnvService, shellEnvService, h
         }
         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 requiredKeys = requiredClaudeKeys.filter((key) => key in effectiveEnv);
         const sourceFiles = sources.map((s) => s.path);
         const result = await renderFlow({ keys, requiredKeys, yes, sourceFiles });
         if (!result?.confirmed) {

package/dist/commands/preset/create.js

@@ -1,8 +1,10 @@
 import { readFile } from 'node:fs/promises';
 import { extname } from 'node:path';
 import { parse as parseYaml } from 'yaml';
+import { requiredClaudeKeys } from '../../core/claude-required-keys.js';
 import { CliError } from '../../core/errors.js';
 import { ensureGitignoreEntry } from '../../core/gitignore.js';
+import { envMapSchema } from '../../core/schema.js';
 import { toProcessEnvMap } from '../../core/process-env.js';
 export async function readEnvFile(filePath) {
     try {
@@ -36,9 +38,44 @@ export async function readEnvFile(filePath) {
         throw new CliError(`Failed to read env file: ${filePath}`, 2);
     }
 }
-export function createPresetCreateCommand({ presetService, projectEnvService, renderFlow, ensureGitignore = (dir, entry) => ensureGitignoreEntry(dir, entry), }) {
+function getDetectedEnv(sources) {
+    return toProcessEnvMap(sources.reduce((acc, source) => ({ ...acc, ...source.env }), {}));
+}
+function omitKeys(env, keys) {
+    return envMapSchema.parse(Object.fromEntries(Object.entries(env).filter(([key]) => !keys.includes(key))));
+}
+function buildSourceBackups(sources, selectedKeys, selectedEnv) {
+    const backups = new Map();
+    for (const source of sources) {
+        backups.set(source.path, envMapSchema.parse({}));
+    }
+    for (const key of selectedKeys) {
+        for (const source of [...sources].reverse()) {
+            if (!(key in source.env)) {
+                continue;
+            }
+            if (source.env[key] !== selectedEnv[key]) {
+                continue;
+            }
+            const current = backups.get(source.path) ?? envMapSchema.parse({});
+            backups.set(source.path, envMapSchema.parse({
+                ...current,
+                [key]: source.env[key],
+            }));
+            break;
+        }
+    }
+    return sources.map((source) => ({
+        file: source.path,
+        backup: backups.get(source.path) ?? envMapSchema.parse({}),
+    }));
+}
+export function createPresetCreateCommand({ presetService, projectEnvService, claudeSettingsEnvService, historyService, renderFlow, ensureGitignore = (dir, entry) => ensureGitignoreEntry(dir, entry), }) {
     return async function createPreset({ cwd }) {
-        const result = await renderFlow();
+        const sources = claudeSettingsEnvService ? await claudeSettingsEnvService.read() : [];
+        const detectedEnv = claudeSettingsEnvService ? getDetectedEnv(sources) : {};
+        const requiredKeys = requiredClaudeKeys.filter((key) => key in detectedEnv);
+        const result = await renderFlow({ detectedEnv, requiredKeys });
         if (!result)
             return;
         const selectedEnv = {};
@@ -46,16 +83,40 @@ export function createPresetCreateCommand({ presetService, projectEnvService, re
             selectedEnv[key] = result.env[key] ?? '';
         }
         const timestamp = new Date().toISOString();
+        const selectedKeys = result.selectedKeys;
+        const sourceBackups = result.source === 'detected'
+            ? buildSourceBackups(sources, selectedKeys, selectedEnv)
+            : [];
         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,
-        });
+        else {
+            await presetService.write({
+                name: result.presetName,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                env: selectedEnv,
+            });
+        }
+        if (result.source === 'detected' && claudeSettingsEnvService && historyService) {
+            await historyService.write({
+                timestamp,
+                action: 'preset-create',
+                projectPath: cwd,
+                presetName: result.presetName,
+                destination: result.destination,
+                migratedKeys: selectedKeys,
+                sources: sourceBackups,
+            });
+            await claudeSettingsEnvService.write(sources.map((source) => ({
+                path: source.path,
+                env: omitKeys(source.env, Object.keys(sourceBackups.find((entry) => entry.file === source.path)?.backup ?? {})),
+            })));
+        }
+        return {
+            presetName: result.presetName,
+            source: result.destination,
+        };
     };
 }

package/dist/commands/restore.js

@@ -2,9 +2,12 @@ import React from 'react';
 import { Box, Text } from 'ink';
 import { CliError } from '../core/errors.js';
 const h = React.createElement;
+function isRestorableRecord(record) {
+    return record.action === 'init' || record.action === 'restore' || record.action === 'preset-create';
+}
 export function createRestoreCommand({ historyService, claudeSettingsEnvService, shellEnvService, settingsEnvService, presetService, renderFlow, renderEnvSummary, }) {
     return async function restore({ yes = false } = {}) {
-        const records = await historyService.list();
+        const records = (await historyService.list()).filter(isRestorableRecord);
         const result = await renderFlow({ records, yes });
         if (!result?.confirmed) {
             return;
@@ -33,6 +36,27 @@ export function createRestoreCommand({ historyService, claudeSettingsEnvService,
             });
             return;
         }
+        if (record.action === 'preset-create') {
+            const mergedBackup = Object.fromEntries(record.sources.flatMap((source) => Object.entries(source.backup)));
+            const current = await claudeSettingsEnvService.read();
+            await claudeSettingsEnvService.write(current.map((source) => ({
+                path: source.path,
+                env: {
+                    ...source.env,
+                    ...(record.sources.find((entry) => entry.file === source.path)?.backup ?? {}),
+                },
+            })));
+            await renderEnvSummary({
+                title: `Restored from detected preset ${record.presetName}`,
+                env: mergedBackup,
+                toFiles: record.sources.map((source) => source.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 (record.action !== 'restore') {
+            throw new CliError('Restore record type is not supported');
+        }
         if (result.targetType === 'settings') {
             const currentSettings = await settingsEnvService.read();
             await settingsEnvService.write({

package/dist/commands/run.js

@@ -1,38 +1,42 @@
-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, json = false, cwd, }) {
-        // Step 0: Check settings files for init-managed keys
+import { requiredClaudeKeys } from '../core/claude-required-keys.js';
+const detectTriggerKeys = ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL'];
+function getDetectedEnv(sources) {
+    return sources.reduce((acc, source) => ({ ...acc, ...source.env }), {});
+}
+export function createRunCommand({ claudeSettingsEnvService, presetService, projectEnvService, projectStateService, findClaude, renderPresetSelect, spawnCommand, stdout = process.stdout }) {
+    return async function run({ args = [], dryRun = false, yes = false, json = false, skipDetect = false, cwd }) {
         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.`);
+        const detectedEnv = getDetectedEnv(sources);
+        const requiredKeys = requiredClaudeKeys.filter((key) => key in detectedEnv);
+        const hasDetectTrigger = detectTriggerKeys.some((key) => key in detectedEnv);
+        if (!skipDetect && hasDetectTrigger) {
+            return {
+                status: 'needs-preset',
+                detectedEnv,
+                requiredKeys,
+            };
         }
         // 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 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".');
+            return {
+                status: 'needs-preset',
+                detectedEnv,
+                requiredKeys,
+            };
         }
         // 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);
+            const idx = presets.findIndex(p => p.name === savedRef.presetName && p.source === savedRef.source);
             if (idx >= 0)
                 defaultIndex = idx;
         }
@@ -52,7 +56,7 @@ export function createRunCommand({ claudeSettingsEnvService, presetService, proj
         // Step 4: Save selection
         await projectStateService.saveLastPreset(cwd, {
             presetName: selected.name,
-            source: selected.source,
+            source: selected.source
         });
         // Step 5: Resolve claude command
         let command;
@@ -72,7 +76,7 @@ export function createRunCommand({ claudeSettingsEnvService, presetService, proj
                 command: [command, ...claudeArgs],
                 env: selected.env
             }, null, 2) + '\n');
-            return;
+            return { status: 'executed' };
         }
         const presetKeys = new Set(Object.keys(selected.env));
         const envBlock = formatRunEnvBlock(selected.env, presetKeys);
@@ -80,9 +84,10 @@ export function createRunCommand({ claudeSettingsEnvService, presetService, proj
         if (dryRun) {
             const preview = [command, ...claudeArgs].join(' ');
             stdout.write(`Would run: ${preview}\n`);
-            return;
+            return { status: 'executed' };
         }
         // Step 7: Spawn
         await spawnCommand(command, claudeArgs, { ...process.env, ...selected.env });
+        return { status: 'executed' };
     };
 }

package/dist/core/claude-required-keys.js

@@ -0,0 +1,8 @@
+export const requiredClaudeKeys = [
+    'ANTHROPIC_AUTH_TOKEN',
+    'ANTHROPIC_BASE_URL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    'ANTHROPIC_REASONING_MODEL',
+];

package/dist/core/schema.js

@@ -32,7 +32,17 @@ const restoreHistorySchema = z.object({
     targetType: z.enum(['settings', 'preset']),
     targetName: z.string(),
 });
+const presetCreateHistorySchema = z.object({
+    timestamp: z.string().datetime({ offset: true }),
+    action: z.literal('preset-create'),
+    projectPath: z.string(),
+    presetName: z.string(),
+    destination: z.enum(['global', 'project']),
+    migratedKeys: z.array(envKeySchema),
+    sources: z.array(sourceEntrySchema),
+});
 export const historySchema = z.discriminatedUnion('action', [
     initHistorySchema,
     restoreHistorySchema,
+    presetCreateHistorySchema,
 ]);

package/dist/flows/preset-create-flow.js

@@ -1,14 +1,62 @@
-export function createPresetCreateFlowState() {
+export function createPresetCreateFlowState(input) {
+    const detectedEnv = input?.detectedEnv ?? {};
+    const requiredKeys = input?.requiredKeys ?? [];
+    const detectedKeys = Object.keys(detectedEnv).sort();
+    const selectedKeys = requiredKeys.filter((key) => key in detectedEnv);
+    if (detectedKeys.length > 0) {
+        return {
+            step: 'detectedPrompt',
+            env: detectedEnv,
+            allKeys: detectedKeys,
+            selectedKeys,
+            requiredKeys: selectedKeys,
+            presetName: '',
+        };
+    }
     return {
         step: 'source',
         env: {},
         allKeys: [],
         selectedKeys: [],
+        requiredKeys: [],
         presetName: '',
     };
 }
 export function advancePresetCreateFlow(state, action) {
     switch (state.step) {
+        case 'detectedPrompt':
+            if (action.type === 'accept-detected-prompt') {
+                return {
+                    ...state,
+                    step: 'detected',
+                };
+            }
+            if (action.type === 'reject-detected-prompt') {
+                const { source: _source, ...rest } = state;
+                return {
+                    ...rest,
+                    step: 'source',
+                };
+            }
+            return state;
+        case 'detected':
+            if (action.type === 'toggle-detected-key') {
+                if (state.requiredKeys.includes(action.key) || !state.allKeys.includes(action.key)) {
+                    return state;
+                }
+                const selectedKeys = state.selectedKeys.includes(action.key)
+                    ? state.selectedKeys.filter((key) => key !== action.key)
+                    : [...state.selectedKeys, action.key].sort();
+                return { ...state, selectedKeys };
+            }
+            if (action.type === 'confirm-detected-keys') {
+                return {
+                    ...state,
+                    step: 'name',
+                    source: 'detected',
+                };
+            }
+            return state;
         case 'source':
             if (action.type !== 'select-source')
                 return state;

package/dist/flows/restore-flow.js

@@ -1,7 +1,26 @@
-export function createRestoreFlowState(records) {
+export function createRestoreFlowState(records, cwd) {
+    const currentProjectRecords = records
+        .filter((record) => 'projectPath' in record && record.projectPath === cwd)
+        .sort((left, right) => right.timestamp.localeCompare(left.timestamp));
+    const otherHistoryRecords = records
+        .filter((record) => !('projectPath' in record) || record.projectPath !== cwd)
+        .sort((left, right) => right.timestamp.localeCompare(left.timestamp));
+    const orderedRecords = [...currentProjectRecords, ...otherHistoryRecords];
+    const groups = [];
+    if (currentProjectRecords.length > 0) {
+        groups.push({ title: 'Current project', start: 0, end: currentProjectRecords.length });
+    }
+    if (otherHistoryRecords.length > 0) {
+        groups.push({
+            title: 'Other history',
+            start: currentProjectRecords.length,
+            end: orderedRecords.length,
+        });
+    }
     return {
         step: 'record',
-        records,
+        records: orderedRecords,
+        groups,
     };
 }
 export function advanceRestoreFlow(state, action) {
@@ -14,7 +33,7 @@ export function advanceRestoreFlow(state, action) {
             if (!selectedRecord) {
                 return state;
             }
-            if (selectedRecord.action === 'init') {
+            if (selectedRecord.action === 'init' || selectedRecord.action === 'preset-create') {
                 return {
                     ...state,
                     step: 'confirm',
@@ -41,19 +60,18 @@ export function advanceRestoreFlow(state, action) {
                     targetType: 'settings',
                 };
             }
-            const targetName = action.targetName;
             return {
                 ...state,
                 step: 'confirm',
                 targetType: 'preset',
-                targetName,
+                targetName: action.targetName,
             };
-        case 'confirm':
+        case 'confirm': {
             if (action.type !== 'confirm' || !state.selectedTimestamp) {
                 return state;
             }
             const selectedRecord = state.records.find((record) => record.timestamp === state.selectedTimestamp);
-            if (selectedRecord?.action === 'init') {
+            if (selectedRecord?.action === 'init' || selectedRecord?.action === 'preset-create') {
                 return {
                     ...state,
                     step: 'done',
@@ -69,6 +87,7 @@ export function advanceRestoreFlow(state, action) {
                 ...state,
                 step: 'done',
             };
+        }
         case 'done':
             return state;
     }

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

@@ -3,6 +3,17 @@ import { useState } from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
 import { advancePresetCreateFlow, createPresetCreateFlowState, } from '../flows/preset-create-flow.js';
 import { EnvSummary } from './summary.js';
+function DetectedPromptStep({ cursor }) {
+    const options = ['Generate from detected config', 'Choose another source'];
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Detected existing configuration" }), _jsx(Text, { dimColor: true, children: "Use the currently detected settings to generate a preset?" }), _jsx(Text, { dimColor: true, children: "\u2191/k \u2193/j navigate \u00B7 enter confirm \u00B7 q cancel" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: options.map((label, i) => (_jsxs(Box, { children: [_jsx(Text, { children: i === cursor ? '❯ ' : '  ' }), _jsx(Text, { ...(i === cursor ? { color: 'cyan' } : {}), children: label })] }, label))) })] }));
+}
+function DetectedKeysStep({ keys, selectedKeys, requiredKeys, cursor, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Select detected env keys to migrate" }), _jsx(Text, { dimColor: true, children: "\u2191/k \u2193/j navigate \u00B7 space toggle optional keys \u00B7 enter confirm" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: keys.map((key, i) => {
+                    const isSelected = selectedKeys.includes(key);
+                    const isRequired = requiredKeys.includes(key);
+                    return (_jsxs(Box, { children: [_jsx(Text, { children: i === cursor ? '❯ ' : '  ' }), _jsx(Text, { color: isSelected ? 'green' : '', children: isSelected ? '[x]' : '[ ]' }), _jsx(Text, { children: isRequired ? ' ! ' : '   ' }), _jsxs(Text, { children: [" ", key] })] }, key));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "! required key \u00B7 q cancel" }) })] }));
+}
 function SourceStep({ cursor }) {
     const options = [
         { label: 'File import', value: 'file' },
@@ -32,9 +43,11 @@ function DestinationStep({ cursor }) {
     ];
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Select save destination" }), _jsx(Text, { dimColor: true, children: "\u2191/k \u2193/j navigate \u00B7 enter confirm" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: options.map((opt, i) => (_jsxs(Box, { children: [_jsx(Text, { children: i === cursor ? '❯ ' : '  ' }), _jsx(Text, { ...(i === cursor ? { color: 'cyan' } : {}), children: opt.label })] }, opt.value))) })] }));
 }
-export function PresetCreateApp({ onSubmit, readFile, globalPresetPath, projectEnvPath, }) {
+export function PresetCreateApp({ onSubmit, readFile, globalPresetPath, projectEnvPath, detectedEnv, requiredKeys, }) {
     const { exit } = useApp();
-    const [state, setState] = useState(createPresetCreateFlowState);
+    const [state, setState] = useState(() => createPresetCreateFlowState(detectedEnv
+        ? (requiredKeys ? { detectedEnv, requiredKeys } : { detectedEnv })
+        : undefined));
     const [textInput, setTextInput] = useState('');
     const [listCursor, setListCursor] = useState(0);
     const [allKeys, setAllKeys] = useState([]);
@@ -44,6 +57,58 @@ export function PresetCreateApp({ onSubmit, readFile, globalPresetPath, projectE
             exit();
             return;
         }
+        if (state.step === 'detectedPrompt') {
+            if (input === 'q') {
+                exit();
+                return;
+            }
+            if (key.upArrow || input === 'k') {
+                setListCursor((c) => Math.max(0, c - 1));
+                return;
+            }
+            if (key.downArrow || input === 'j') {
+                setListCursor((c) => Math.min(1, c + 1));
+                return;
+            }
+            if (key.return) {
+                setState((s) => advancePresetCreateFlow(s, listCursor === 0
+                    ? { type: 'accept-detected-prompt' }
+                    : { type: 'reject-detected-prompt' }));
+                setListCursor(0);
+                setTextInput('');
+                return;
+            }
+        }
+        if (state.step === 'detected') {
+            if (input === 'q') {
+                exit();
+                return;
+            }
+            if (key.upArrow || input === 'k') {
+                setListCursor((c) => Math.max(0, c - 1));
+                return;
+            }
+            if (key.downArrow || input === 'j') {
+                setListCursor((c) => Math.min(state.allKeys.length - 1, c + 1));
+                return;
+            }
+            if (input === ' ') {
+                const targetKey = state.allKeys[listCursor];
+                if (targetKey) {
+                    setState((s) => advancePresetCreateFlow(s, {
+                        type: 'toggle-detected-key',
+                        key: targetKey,
+                    }));
+                }
+                return;
+            }
+            if (key.return) {
+                setState((s) => advancePresetCreateFlow(s, { type: 'confirm-detected-keys' }));
+                setListCursor(0);
+                setTextInput('');
+                return;
+            }
+        }
         if (state.step === 'source') {
             if (input === 'q') {
                 exit();
@@ -261,7 +326,7 @@ export function PresetCreateApp({ onSubmit, readFile, globalPresetPath, projectE
     if (state.step === 'done') {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "green", children: "Done" }) }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [state.step === 'source' && _jsx(SourceStep, { cursor: listCursor }), state.step === 'filePath' && (_jsx(FilePathStep, { value: textInput, ...(state.error ? { error: state.error } : {}) })), state.step === 'keys' && (_jsx(KeysStep, { keys: allKeys, selectedKeys: state.selectedKeys, cursor: listCursor })), state.step === 'manualInput' && (_jsx(ManualInputStep, { entries: state.selectedKeys.map((k) => [k, state.env[k] ?? '']), value: textInput, ...(state.error ? { error: state.error } : {}) })), state.step === 'name' && _jsx(NameStep, { value: textInput }), state.step === 'destination' && _jsx(DestinationStep, { cursor: listCursor }), state.step === 'confirm' && state.destination ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(EnvSummary, { title: `Preset: ${state.presetName}`, entries: Object.entries(state.env)
+    return (_jsxs(Box, { flexDirection: "column", children: [state.step === 'detectedPrompt' && _jsx(DetectedPromptStep, { cursor: listCursor }), state.step === 'detected' && (_jsx(DetectedKeysStep, { keys: state.allKeys, selectedKeys: state.selectedKeys, requiredKeys: state.requiredKeys, cursor: listCursor })), state.step === 'source' && _jsx(SourceStep, { cursor: listCursor }), state.step === 'filePath' && (_jsx(FilePathStep, { value: textInput, ...(state.error ? { error: state.error } : {}) })), state.step === 'keys' && (_jsx(KeysStep, { keys: allKeys, selectedKeys: state.selectedKeys, cursor: listCursor })), state.step === 'manualInput' && (_jsx(ManualInputStep, { entries: state.selectedKeys.map((k) => [k, state.env[k] ?? '']), value: textInput, ...(state.error ? { error: state.error } : {}) })), state.step === 'name' && _jsx(NameStep, { value: textInput }), state.step === 'destination' && _jsx(DestinationStep, { cursor: listCursor }), state.step === 'confirm' && state.destination ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(EnvSummary, { title: `Preset: ${state.presetName}`, entries: Object.entries(state.env)
                             .filter(([k]) => state.selectedKeys.includes(k))
                             .sort(([a], [b]) => a.localeCompare(b)), mask: true, ...(state.filePath ? { fromFiles: [state.filePath] } : {}), toFiles: [
                             state.destination === 'global'

package/dist/ink/restore-app.js

@@ -3,6 +3,21 @@ import { useEffect, useMemo, useState } from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
 import { advanceRestoreFlow } from '../flows/restore-flow.js';
 import { EnvEntries, EnvSummary } from './summary.js';
+export function getRestorePreviewSections(record) {
+    if (!record) {
+        return [];
+    }
+    if (record.action === 'init' || record.action === 'preset-create') {
+        return record.sources
+            .filter((source) => Object.keys(source.backup).length > 0)
+            .map((source) => ({
+            file: source.file,
+            entries: Object.entries(source.backup)
+                .sort(([left], [right]) => left.localeCompare(right)),
+        }));
+    }
+    return [];
+}
 export function RestoreApp({ state, onSubmit, }) {
     const { exit } = useApp();
     const [currentState, setCurrentState] = useState(state);
@@ -13,9 +28,11 @@ export function RestoreApp({ state, onSubmit, }) {
         ? recordAtCursor
         : selectedRecord ?? currentState.records[0];
     const restoreEntries = useMemo(() => activeRecord
-        ? Object.entries(activeRecord.action === 'init'
+        ? Object.entries(activeRecord.action === 'init' || activeRecord.action === 'preset-create'
             ? Object.fromEntries(activeRecord.sources.flatMap((s) => Object.entries(s.backup)))
-            : activeRecord.backup).sort(([left], [right]) => left.localeCompare(right))
+            : activeRecord.action === 'restore'
+                ? activeRecord.backup
+                : {}).sort(([left], [right]) => left.localeCompare(right))
         : [], [activeRecord]);
     const fromFiles = useMemo(() => {
         if (!activeRecord || activeRecord.action !== 'init') {
@@ -23,12 +40,7 @@ export function RestoreApp({ state, onSubmit, }) {
         }
         return activeRecord.shellWrites.map((sw) => sw.filePath);
     }, [activeRecord]);
-    const toFiles = useMemo(() => {
-        if (!activeRecord || activeRecord.action !== 'init') {
-            return [];
-        }
-        return activeRecord.sources.map((s) => s.file);
-    }, [activeRecord]);
+    const previewSections = useMemo(() => getRestorePreviewSections(activeRecord), [activeRecord]);
     useEffect(() => {
         setCurrentState(state);
         setCursor(0);
@@ -96,7 +108,10 @@ export function RestoreApp({ state, onSubmit, }) {
             exit();
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Restore record" }), currentState.step === 'record' ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "\u2191/k \u2193/j navigate \u00B7 enter confirm \u00B7 q cancel" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", width: 28, marginRight: 2, children: [_jsx(Text, { bold: true, color: "cyan", children: "History" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: currentState.records.map((record, index) => (_jsxs(Text, { children: [index === cursor ? '❯ ' : '  ', record.timestamp] }, record.timestamp))) })] }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Preview" }), activeRecord?.action === 'init' ? (_jsxs(Box, { flexDirection: "column", children: [fromFiles.length > 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "From:" }), fromFiles.map((file) => (_jsxs(Text, { color: "cyan", children: ["  ", file] }, file)))] })) : null, toFiles.length > 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "To:" }), toFiles.map((file) => (_jsxs(Text, { color: "cyan", children: ["  ", file] }, file)))] })) : null] })) : (_jsxs(Text, { dimColor: true, children: ["Restore to ", activeRecord?.targetType === 'preset' ? `preset ${activeRecord.targetName}` : activeRecord?.targetType ?? 'settings'] })), _jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(EnvEntries, { entries: restoreEntries }) })] })] })] })) : null, currentState.step === 'target' ? (_jsxs(Text, { children: ["Select target for ", selectedRecord?.timestamp ?? 'record', ": settings or preset"] })) : null, currentState.step === 'confirm' && selectedRecord?.action === 'init' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Confirm restore from ", _jsx(Text, { color: "cyan", children: selectedRecord.timestamp })] }), _jsx(EnvSummary, { title: "Will restore", entries: restoreEntries, ...(fromFiles.length > 0 ? { fromFiles } : {}), ...(toFiles.length > 0 ? { toFiles } : {}) })] })) : null, currentState.step === 'confirm' && selectedRecord?.action !== 'init' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Confirm restore from ", _jsx(Text, { color: "cyan", children: selectedRecord?.timestamp ?? 'record' }), " to", ' ', _jsx(Text, { color: "green", children: currentState.targetType === 'preset'
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Restore record" }), currentState.step === 'record' ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "\u2191/k \u2193/j navigate \u00B7 enter confirm \u00B7 q cancel" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", width: 28, marginRight: 2, children: [_jsx(Text, { bold: true, color: "cyan", children: "History" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: currentState.groups.map((group) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: group.title }), currentState.records.slice(group.start, group.end).map((record, index) => {
+                                                    const actualIndex = group.start + index;
+                                                    return (_jsxs(Text, { children: [actualIndex === cursor ? '❯ ' : '  ', record.timestamp] }, record.timestamp));
+                                                })] }, group.title))) })] }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Preview" }), activeRecord?.action === 'restore' ? (_jsxs(Text, { dimColor: true, children: ["Restore to ", activeRecord.targetType === 'preset' ? `preset ${activeRecord.targetName}` : activeRecord.targetType] })) : null, previewSections.map((section) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "cyan", children: section.file }), _jsx(EnvEntries, { entries: section.entries })] }, section.file))), previewSections.length === 0 ? (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(EnvEntries, { entries: restoreEntries }) })) : null] })] })] })) : null, currentState.step === 'target' ? (_jsxs(Text, { children: ["Select target for ", selectedRecord?.timestamp ?? 'record', ": settings or preset"] })) : null, currentState.step === 'confirm' && selectedRecord?.action === 'init' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Confirm restore from ", _jsx(Text, { color: "cyan", children: selectedRecord.timestamp })] }), _jsx(EnvSummary, { title: "Will restore", entries: restoreEntries, ...(fromFiles.length > 0 ? { fromFiles } : {}), toFiles: previewSections.map((section) => section.file) })] })) : null, currentState.step === 'confirm' && selectedRecord?.action === 'preset-create' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Confirm restore from ", _jsx(Text, { color: "cyan", children: selectedRecord.timestamp })] }), previewSections.map((section) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "cyan", children: section.file }), _jsx(EnvEntries, { entries: section.entries })] }, section.file)))] })) : null, currentState.step === 'confirm' && selectedRecord?.action === 'restore' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Confirm restore from ", _jsx(Text, { color: "cyan", children: selectedRecord.timestamp }), " to", ' ', _jsx(Text, { color: "green", children: currentState.targetType === 'preset'
                                     ? `preset ${currentState.targetName}`
                                     : currentState.targetType ?? 'settings' })] }), _jsx(EnvSummary, { title: "Will restore", entries: restoreEntries })] })) : null, currentState.step === 'done' ? (_jsxs(Text, { color: "green", children: ['\n', "Restore complete"] })) : null, currentState.step !== 'done' ? (_jsx(Text, { children: "Press Enter to confirm or q to cancel" })) : null] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lkangd/cc-env",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Manage runtime environment variables for Claude Code",
   "homepage": "https://github.com/lkangd/cc-env#readme",
   "bugs": {

package/dist/ink/init-app.js

@@ -1,54 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useState } from 'react';
-import { Box, Text, useApp, useInput } from 'ink';
-import { advanceInitFlow, createInitFlowState, } from '../flows/init-flow.js';
-export function InitApp({ keys = [], requiredKeys = [], sourceFiles = [], onSubmit, }) {
-    const { exit } = useApp();
-    const [cursor, setCursor] = useState(0);
-    const [flowState, setFlowState] = useState(() => createInitFlowState(keys, requiredKeys));
-    useEffect(() => {
-        if (!onSubmit) {
-            return;
-        }
-        if (keys.length === 0) {
-            onSubmit({ confirmed: false, selectedKeys: [] });
-            exit();
-        }
-    }, [exit, keys.length, onSubmit]);
-    useInput((input, key) => {
-        if (!onSubmit) {
-            return;
-        }
-        if (key.upArrow || input === 'k') {
-            setCursor((c) => Math.max(0, c - 1));
-            return;
-        }
-        if (key.downArrow || input === 'j') {
-            setCursor((c) => Math.min(keys.length - 1, c + 1));
-            return;
-        }
-        if (input === ' ') {
-            const targetKey = keys[cursor];
-            if (targetKey) {
-                setFlowState((prev) => advanceInitFlow(prev, { type: 'toggle-key', key: targetKey }));
-            }
-            return;
-        }
-        if (key.return) {
-            onSubmit({ confirmed: true, selectedKeys: flowState.selectedKeys });
-            exit();
-            return;
-        }
-        if (key.escape || input.toLowerCase() === 'q') {
-            onSubmit({ confirmed: false, selectedKeys: [] });
-            exit();
-        }
-    });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Select env keys to migrate into managed shell config" }), sourceFiles.length > 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Source:" }), sourceFiles.map((file) => (_jsxs(Text, { color: "cyan", children: ["  ", file] }, file)))] })) : null, _jsx(Text, { dimColor: true, children: "\u2191/k \u2193/j navigate \u00B7 space toggle \u00B7 enter confirm \u00B7 q cancel" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: keys.map((key, i) => {
-                    const isRequired = requiredKeys.includes(key);
-                    const isSelected = flowState.selectedKeys.includes(key);
-                    const isCursor = i === cursor;
-                    const checkbox = isSelected ? '[x]' : '[ ]';
-                    return (_jsxs(Box, { children: [_jsx(Text, { children: isCursor ? '❯ ' : '  ' }), _jsx(Text, { color: isSelected ? 'green' : '', children: checkbox }), _jsxs(Text, { children: [" ", key] }), isRequired ? _jsx(Text, { dimColor: true, children: " (required)" }) : null] }, key));
-                }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [flowState.selectedKeys.length, " of ", keys.length, " selected"] }) })] }));
-}