@lkangd/cc-env 1.0.0

package/dist/core/find-claude.js

@@ -0,0 +1,64 @@
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { CliError } from './errors.js';
+function resolveToJsFile(filePath) {
+    try {
+        const realPath = realpathSync(filePath);
+        if (realPath.endsWith('.js'))
+            return realPath;
+        if (existsSync(realPath)) {
+            const content = readFileSync(realPath, 'utf-8');
+            if (content.startsWith('#!/usr/bin/env node') ||
+                /^#!.*\/node$/m.test(content) ||
+                content.includes('require(') ||
+                content.includes('import ')) {
+                return realPath;
+            }
+        }
+        for (const candidate of [
+            realPath + '.js',
+            realPath.replace(/\/bin\//, '/lib/') + '.js',
+            realPath.replace(/\/\.bin\//, '/lib/bin/') + '.js',
+        ]) {
+            if (existsSync(candidate))
+                return candidate;
+        }
+        return realPath;
+    }
+    catch {
+        return filePath;
+    }
+}
+export function findClaudeExecutable() {
+    try {
+        let claudePath = execSync('which claude', { encoding: 'utf-8' }).trim();
+        const aliasMatch = claudePath.match(/:\s*aliased to\s+(.+)$/);
+        if (aliasMatch?.[1])
+            claudePath = aliasMatch[1];
+        if (existsSync(claudePath)) {
+            const content = readFileSync(claudePath, 'utf-8');
+            if (content.startsWith('#!/bin/bash')) {
+                const execMatch = content.match(/exec\s+"([^"]+)"/);
+                if (execMatch?.[1])
+                    return resolveToJsFile(execMatch[1]);
+            }
+        }
+        return resolveToJsFile(claudePath);
+    }
+    catch { }
+    const home = process.env.HOME ?? process.cwd();
+    const localWrapper = join(home, '.claude', 'local', 'claude');
+    if (existsSync(localWrapper)) {
+        const content = readFileSync(localWrapper, 'utf-8');
+        if (content.startsWith('#!/bin/bash')) {
+            const execMatch = content.match(/exec\s+"([^"]+)"/);
+            if (execMatch?.[1])
+                return resolveToJsFile(execMatch[1]);
+        }
+    }
+    const localBin = join(home, '.claude', 'local', 'node_modules', '.bin', 'claude');
+    if (existsSync(localBin))
+        return resolveToJsFile(localBin);
+    throw new CliError('Claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code');
+}

package/dist/core/format.js

@@ -0,0 +1,23 @@
+import { maskValue } from './mask.js';
+export function formatEnvBlock(env) {
+    return Object.entries(env)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${maskValue(key, value)}`)
+        .join('\n');
+}
+export function formatRunEnvBlock(env, presetKeys) {
+    const entries = Object.entries(env).sort(([a], [b]) => a.localeCompare(b));
+    const presetEntries = entries.filter(([key]) => presetKeys.has(key));
+    const otherCount = entries.length - presetEntries.length;
+    const lines = presetEntries.map(([key, value]) => `${key}=${maskValue(key, value)}`);
+    if (otherCount > 0) {
+        lines.push(`+${otherCount} other env vars applied`);
+    }
+    return lines.join('\n');
+}
+export function formatRestorePreview(env) {
+    return Object.entries(env)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${value}`)
+        .join('\n');
+}

package/dist/core/fs.js

@@ -0,0 +1,12 @@
+import { mkdir, rename, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+export async function ensureParentDir(filePath) {
+    await mkdir(dirname(filePath), { recursive: true });
+}
+export async function atomicWriteFile(filePath, content) {
+    const parentDir = dirname(filePath);
+    const tempFilePath = join(parentDir, `.${basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+    await ensureParentDir(filePath);
+    await writeFile(tempFilePath, content, 'utf8');
+    await rename(tempFilePath, filePath);
+}

package/dist/core/gitignore.js

@@ -0,0 +1,23 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export function isGitRepo(dir) {
+    return existsSync(join(dir, '.git'));
+}
+export async function ensureGitignoreEntry(dir, entry) {
+    if (!isGitRepo(dir))
+        return;
+    const gitignorePath = join(dir, '.gitignore');
+    let content = '';
+    try {
+        content = await readFile(gitignorePath, 'utf8');
+    }
+    catch {
+        // .gitignore doesn't exist — will create it
+    }
+    const lines = content.split('\n');
+    if (lines.some((line) => line === entry || line === `${entry}/`))
+        return;
+    const separator = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
+    await writeFile(gitignorePath, `${content}${separator}${entry}\n`, 'utf8');
+}

package/dist/core/lock.js

@@ -0,0 +1,25 @@
+import { open } from 'node:fs/promises';
+import lockfile from 'proper-lockfile';
+import { ensureParentDir } from './fs.js';
+export async function withFileLock(filePath, run) {
+    await ensureParentDir(filePath);
+    const handle = await open(filePath, 'a+');
+    try {
+        const release = await lockfile.lock(filePath, {
+            realpath: false,
+            retries: {
+                retries: 3,
+                factor: 1,
+            },
+        });
+        try {
+            return await run();
+        }
+        finally {
+            await release();
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}

package/dist/core/logger.js

@@ -0,0 +1,8 @@
+import pino from 'pino';
+import { ensureParentDir } from './fs.js';
+import { resolveLogPath } from './paths.js';
+export async function createLogger(globalRoot) {
+    const logPath = resolveLogPath(globalRoot);
+    await ensureParentDir(logPath);
+    return pino(pino.destination(logPath));
+}

package/dist/core/mask.js

@@ -0,0 +1,13 @@
+const sensitiveKeyPattern = /(_TOKEN|_KEY|_SECRET|_PASSWORD)$/i;
+export function isSensitiveKey(key) {
+    return sensitiveKeyPattern.test(key);
+}
+export function maskValue(key, value) {
+    if (!isSensitiveKey(key)) {
+        return value;
+    }
+    if (value.length <= 8) {
+        return '*'.repeat(value.length);
+    }
+    return `${value.slice(0, 9)}********`;
+}

package/dist/core/paths.js

@@ -0,0 +1,32 @@
+import { join } from 'node:path';
+export function resolveGlobalRoot(globalRoot) {
+    return globalRoot ?? join(process.env.HOME ?? process.cwd(), '.cc-env');
+}
+export function resolveClaudeSettingsPath(homeDir = process.env.HOME ?? process.cwd()) {
+    return join(homeDir, '.claude', 'settings.json');
+}
+export function resolveClaudeSettingsLocalPath(homeDir = process.env.HOME ?? process.cwd()) {
+    return join(homeDir, '.claude', 'settings.local.json');
+}
+export function resolveProjectSettingsPath(cwd = process.cwd()) {
+    return join(cwd, '.claude', 'settings.json');
+}
+export function resolveProjectSettingsLocalPath(cwd = process.cwd()) {
+    return join(cwd, '.claude', 'settings.local.json');
+}
+export function resolveShellConfigPaths(homeDir = process.env.HOME ?? process.cwd()) {
+    return {
+        zsh: join(homeDir, '.zshrc'),
+        bash: join(homeDir, '.bashrc'),
+        fish: join(homeDir, '.config', 'fish', 'config.fish'),
+    };
+}
+export function resolvePresetPath(globalRoot, name) {
+    return join(globalRoot, 'presets', `${name}.json`);
+}
+export function resolveHistoryPath(globalRoot, timestamp) {
+    return join(globalRoot, 'history', `${timestamp.replaceAll(':', '-')}.json`);
+}
+export function resolveLogPath(globalRoot) {
+    return join(globalRoot, 'logs', 'app.log');
+}

package/dist/core/process-env.js

@@ -0,0 +1,4 @@
+import { envMapSchema } from './schema.js';
+export function toProcessEnvMap(input) {
+    return envMapSchema.parse(Object.fromEntries(Object.entries(input).filter(([key, value]) => typeof value === 'string' && /^[A-Z0-9_]+$/.test(key))));
+}

package/dist/core/schema.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+const envKeySchema = z.string().regex(/^[A-Z0-9_]+$/);
+export const envMapSchema = z.record(envKeySchema, z.unknown()
+    .refine((value) => value === null || typeof value !== 'object')
+    .transform((value) => String(value)));
+export const presetSchema = z.object({
+    name: z.string(),
+    createdAt: z.string().datetime({ offset: true }),
+    updatedAt: z.string().datetime({ offset: true }),
+    env: envMapSchema,
+});
+const shellWriteSchema = z.object({
+    shell: z.enum(['zsh', 'bash', 'fish']),
+    filePath: z.string(),
+    env: envMapSchema,
+});
+const sourceEntrySchema = z.object({
+    file: z.string(),
+    backup: envMapSchema,
+});
+const initHistorySchema = z.object({
+    timestamp: z.string().datetime({ offset: true }),
+    action: z.literal('init'),
+    migratedKeys: z.array(envKeySchema),
+    sources: z.array(sourceEntrySchema),
+    shellWrites: z.array(shellWriteSchema),
+});
+const restoreHistorySchema = z.object({
+    timestamp: z.string().datetime({ offset: true }),
+    action: z.literal('restore'),
+    backup: envMapSchema,
+    targetType: z.enum(['settings', 'preset']),
+    targetName: z.string(),
+});
+export const historySchema = z.discriminatedUnion('action', [
+    initHistorySchema,
+    restoreHistorySchema,
+]);

package/dist/core/spawn.js

@@ -0,0 +1,26 @@
+import spawn from 'cross-spawn';
+import { CliError } from './errors.js';
+export function spawnCommand(command, args, env) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            env,
+            stdio: 'inherit',
+        });
+        child.once('error', reject);
+        child.once('close', (exitCode, signal) => {
+            if (signal) {
+                reject(new CliError(`Command terminated by signal ${signal}`));
+                return;
+            }
+            if (exitCode === null) {
+                reject(new CliError('Command terminated without an exit code'));
+                return;
+            }
+            if (exitCode !== 0) {
+                reject(new CliError(`Command exited with code ${exitCode}`, exitCode));
+                return;
+            }
+            resolve();
+        });
+    });
+}

package/dist/flows/init-flow.js

@@ -0,0 +1,35 @@
+export function createInitFlowState(availableKeys, requiredKeys) {
+    return {
+        step: 'keys',
+        availableKeys,
+        requiredKeys,
+        selectedKeys: requiredKeys,
+    };
+}
+export function advanceInitFlow(state, action) {
+    if (state.step === 'keys' && action.type === 'toggle-key') {
+        if (state.requiredKeys.includes(action.key)) {
+            return state;
+        }
+        const selectedKeys = state.selectedKeys.includes(action.key)
+            ? state.selectedKeys.filter((key) => key !== action.key)
+            : [...state.selectedKeys, action.key];
+        return {
+            ...state,
+            selectedKeys,
+        };
+    }
+    if (state.step === 'keys' && action.type === 'continue') {
+        return {
+            ...state,
+            step: 'confirm',
+        };
+    }
+    if (state.step === 'confirm' && action.type === 'confirm') {
+        return {
+            ...state,
+            step: 'done',
+        };
+    }
+    return state;
+}

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

@@ -0,0 +1,80 @@
+export function createPresetCreateFlowState() {
+    return {
+        step: 'source',
+        env: {},
+        allKeys: [],
+        selectedKeys: [],
+        presetName: '',
+    };
+}
+export function advancePresetCreateFlow(state, action) {
+    switch (state.step) {
+        case 'source':
+            if (action.type !== 'select-source')
+                return state;
+            return {
+                ...state,
+                step: action.source === 'file' ? 'filePath' : 'manualInput',
+                source: action.source,
+            };
+        case 'filePath':
+            if (action.type === 'set-error') {
+                return { ...state, error: action.error };
+            }
+            if (action.type !== 'set-file-path')
+                return state;
+            return {
+                ...state,
+                step: 'keys',
+                filePath: action.filePath,
+                error: undefined,
+            };
+        case 'keys':
+            if (action.type !== 'select-keys')
+                return state;
+            return {
+                ...state,
+                step: 'name',
+                selectedKeys: action.keys,
+                env: action.env,
+            };
+        case 'manualInput':
+            if (action.type === 'add-manual-pair') {
+                const hasKey = state.selectedKeys.includes(action.key);
+                return {
+                    ...state,
+                    env: { ...state.env, [action.key]: action.value },
+                    selectedKeys: hasKey ? state.selectedKeys : [...state.selectedKeys, action.key],
+                    error: undefined,
+                };
+            }
+            if (action.type === 'set-error') {
+                return { ...state, error: action.error };
+            }
+            if (action.type !== 'finish-manual-input')
+                return state;
+            return { ...state, step: 'name' };
+        case 'name':
+            if (action.type !== 'set-name')
+                return state;
+            return {
+                ...state,
+                step: 'destination',
+                presetName: action.name,
+            };
+        case 'destination':
+            if (action.type !== 'select-destination')
+                return state;
+            return {
+                ...state,
+                step: 'confirm',
+                destination: action.destination,
+            };
+        case 'confirm':
+            if (action.type !== 'confirm')
+                return state;
+            return { ...state, step: 'done' };
+        case 'done':
+            return state;
+    }
+}

package/dist/flows/restore-flow.js

@@ -0,0 +1,75 @@
+export function createRestoreFlowState(records) {
+    return {
+        step: 'record',
+        records,
+    };
+}
+export function advanceRestoreFlow(state, action) {
+    switch (state.step) {
+        case 'record': {
+            if (action.type !== 'select-record') {
+                return state;
+            }
+            const selectedRecord = state.records.find((record) => record.timestamp === action.timestamp);
+            if (!selectedRecord) {
+                return state;
+            }
+            if (selectedRecord.action === 'init') {
+                return {
+                    ...state,
+                    step: 'confirm',
+                    selectedTimestamp: action.timestamp,
+                };
+            }
+            return {
+                ...state,
+                step: 'target',
+                selectedTimestamp: action.timestamp,
+            };
+        }
+        case 'target':
+            if (action.type !== 'select-target' || !state.selectedTimestamp) {
+                return state;
+            }
+            if (action.targetType === 'preset' && !action.targetName) {
+                return state;
+            }
+            if (action.targetType === 'settings') {
+                return {
+                    ...state,
+                    step: 'confirm',
+                    targetType: 'settings',
+                };
+            }
+            const targetName = action.targetName;
+            return {
+                ...state,
+                step: 'confirm',
+                targetType: 'preset',
+                targetName,
+            };
+        case 'confirm':
+            if (action.type !== 'confirm' || !state.selectedTimestamp) {
+                return state;
+            }
+            const selectedRecord = state.records.find((record) => record.timestamp === state.selectedTimestamp);
+            if (selectedRecord?.action === 'init') {
+                return {
+                    ...state,
+                    step: 'done',
+                };
+            }
+            if (!state.targetType) {
+                return state;
+            }
+            if (state.targetType === 'preset' && !state.targetName) {
+                return state;
+            }
+            return {
+                ...state,
+                step: 'done',
+            };
+        case 'done':
+            return state;
+    }
+}

package/dist/ink/init-app.js

@@ -0,0 +1,54 @@
+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"] }) })] }));
+}