@lkangd/cc-env 1.0.0

package/dist/services/history-service.js

@@ -0,0 +1,39 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { atomicWriteFile, ensureParentDir } from '../core/fs.js';
+import { resolveHistoryPath } from '../core/paths.js';
+import { historySchema } from '../core/schema.js';
+function isErrnoException(error) {
+    return error instanceof Error && 'code' in error;
+}
+export function createHistoryService(globalRoot) {
+    return {
+        async write(record) {
+            const stored = historySchema.parse(record);
+            const filePath = resolveHistoryPath(globalRoot, stored.timestamp);
+            await ensureParentDir(filePath);
+            await atomicWriteFile(filePath, `${JSON.stringify(stored, null, 2)}\n`);
+            return stored;
+        },
+        async list() {
+            const dirPath = dirname(resolveHistoryPath(globalRoot, 'placeholder'));
+            try {
+                const entries = await readdir(dirPath, { withFileTypes: true });
+                const fileNames = entries
+                    .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+                    .map((entry) => entry.name)
+                    .sort((a, b) => b.localeCompare(a));
+                return Promise.all(fileNames.map(async (fileName) => {
+                    const content = await readFile(join(dirPath, fileName), 'utf8');
+                    return historySchema.parse(JSON.parse(content));
+                }));
+            }
+            catch (error) {
+                if (isErrnoException(error) && error.code === 'ENOENT') {
+                    return [];
+                }
+                throw error;
+            }
+        },
+    };
+}

package/dist/services/preset-service.js

@@ -0,0 +1,61 @@
+import { readdir, readFile, rm } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { CliError } from '../core/errors.js';
+import { atomicWriteFile } from '../core/fs.js';
+import { resolvePresetPath } from '../core/paths.js';
+import { presetSchema } from '../core/schema.js';
+export function createPresetService(globalRoot) {
+    function getPath(name) {
+        return resolvePresetPath(globalRoot, name);
+    }
+    return {
+        getPath,
+        async write(preset) {
+            const parsed = presetSchema.parse(preset);
+            const filePath = getPath(parsed.name);
+            await atomicWriteFile(filePath, `${JSON.stringify(parsed, null, 2)}\n`);
+            return { ...parsed, filePath };
+        },
+        async read(name) {
+            const filePath = getPath(name);
+            try {
+                const content = await readFile(filePath, 'utf8');
+                const preset = presetSchema.parse(JSON.parse(content));
+                return { ...preset, filePath };
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    throw new CliError(`Preset not found: ${name}`);
+                }
+                throw error;
+            }
+        },
+        async listNames() {
+            const dirPath = dirname(getPath('placeholder'));
+            try {
+                const entries = await readdir(dirPath, { withFileTypes: true });
+                return entries
+                    .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+                    .map((entry) => entry.name.slice(0, -'.json'.length))
+                    .sort();
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    return [];
+                }
+                throw error;
+            }
+        },
+        async remove(name) {
+            const filePath = getPath(name);
+            try {
+                await rm(filePath);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        },
+    };
+}

package/dist/services/project-env-service.js

@@ -0,0 +1,90 @@
+import { access, mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parse, stringify } from 'yaml';
+import { atomicWriteFile } from '../core/fs.js';
+import { CliError } from '../core/errors.js';
+import { envMapSchema } from '../core/schema.js';
+function parseEnvelope(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const obj = value;
+        if (obj.env && typeof obj.env === 'object' && !Array.isArray(obj.env)) {
+            return {
+                env: envMapSchema.parse(obj.env),
+                name: typeof obj.name === 'string' ? obj.name : undefined,
+                createdAt: typeof obj.createdAt === 'string' ? obj.createdAt : undefined,
+                updatedAt: typeof obj.updatedAt === 'string' ? obj.updatedAt : undefined,
+            };
+        }
+    }
+    return { env: envMapSchema.parse(value) };
+}
+export function createProjectEnvService({ cwd }) {
+    const envDir = join(cwd, '.cc-env');
+    const jsonPath = join(envDir, 'env.json');
+    const yamlPath = join(envDir, 'env.yaml');
+    async function exists(filePath) {
+        try {
+            await access(filePath);
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async function resolveMode() {
+        const [jsonExists, yamlExists] = await Promise.all([exists(jsonPath), exists(yamlPath)]);
+        if (jsonExists && yamlExists) {
+            throw new CliError('Project env conflict: env.json and env.yaml both exist');
+        }
+        if (yamlExists) {
+            return 'yaml';
+        }
+        if (jsonExists) {
+            return 'json';
+        }
+        return 'missing';
+    }
+    async function readRaw() {
+        const mode = await resolveMode();
+        if (mode === 'missing') {
+            return { env: envMapSchema.parse({}) };
+        }
+        const filePath = mode === 'yaml' ? yamlPath : jsonPath;
+        const content = await readFile(filePath, 'utf8');
+        const value = mode === 'yaml' ? parse(content) : JSON.parse(content);
+        return parseEnvelope(value ?? {});
+    }
+    return {
+        async read() {
+            const { env } = await readRaw();
+            return env;
+        },
+        async readWithMeta() {
+            return readRaw();
+        },
+        async write(env, meta) {
+            const parsedEnv = envMapSchema.parse(env);
+            await mkdir(envDir, { recursive: true });
+            const mode = await resolveMode();
+            if (meta?.name !== undefined) {
+                const envelope = { name: meta.name, env: parsedEnv };
+                if (meta.createdAt !== undefined)
+                    envelope.createdAt = meta.createdAt;
+                if (meta.updatedAt !== undefined)
+                    envelope.updatedAt = meta.updatedAt;
+                const content = `${JSON.stringify(envelope, null, 2)}\n`;
+                await atomicWriteFile(jsonPath, content);
+                return parsedEnv;
+            }
+            const filePath = mode === 'yaml' ? yamlPath : jsonPath;
+            const content = mode === 'yaml'
+                ? stringify(parsedEnv)
+                : `${JSON.stringify(parsedEnv, null, 2)}\n`;
+            await atomicWriteFile(filePath, content);
+            return parsedEnv;
+        },
+    };
+}

package/dist/services/project-state-service.js

@@ -0,0 +1,26 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { atomicWriteFile } from '../core/fs.js';
+export function createProjectStateService(globalRoot) {
+    const filePath = join(globalRoot, 'project-state.json');
+    async function readAll() {
+        try {
+            const content = await readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch {
+            return {};
+        }
+    }
+    return {
+        async getLastPreset(cwd) {
+            const state = await readAll();
+            return state[cwd];
+        },
+        async saveLastPreset(cwd, ref) {
+            const state = await readAll();
+            state[cwd] = ref;
+            await atomicWriteFile(filePath, `${JSON.stringify(state, null, 2)}\n`);
+        },
+    };
+}

package/dist/services/runtime-env-service.js

@@ -0,0 +1,13 @@
+import { envMapSchema } from '../core/schema.js';
+export function createRuntimeEnvService() {
+    return {
+        merge({ processEnv, settingsEnv, projectEnv, presetEnv, }) {
+            return envMapSchema.parse({
+                ...processEnv,
+                ...settingsEnv,
+                ...projectEnv,
+                ...presetEnv,
+            });
+        },
+    };
+}

package/dist/services/settings-env-service.js

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises';
+import { atomicWriteFile } from '../core/fs.js';
+import { envMapSchema } from '../core/schema.js';
+export function createSettingsEnvService({ settingsPath }) {
+    return {
+        async read() {
+            try {
+                const content = await readFile(settingsPath, 'utf8');
+                const json = JSON.parse(content);
+                return envMapSchema.parse(json.env ?? {});
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    return envMapSchema.parse({});
+                }
+                throw error;
+            }
+        },
+        async write(env) {
+            const parsedEnv = envMapSchema.parse(env);
+            let json = {};
+            try {
+                const content = await readFile(settingsPath, 'utf8');
+                json = JSON.parse(content);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+            json.env = parsedEnv;
+            await atomicWriteFile(settingsPath, `${JSON.stringify(json, null, 2)}\n`);
+            return parsedEnv;
+        },
+    };
+}

package/dist/services/shell-env-service.js

@@ -0,0 +1,77 @@
+import { readFile } from 'node:fs/promises';
+import { atomicWriteFile } from '../core/fs.js';
+import { resolveShellConfigPaths } from '../core/paths.js';
+import { envMapSchema } from '../core/schema.js';
+const startMarker = '# >>> cc-env >>>';
+const endMarker = '# <<< cc-env <<<';
+function parseManagedEnv(content) {
+    const match = content.match(/# >>> cc-env >>>[\s\S]*?# <<< cc-env <<</);
+    if (!match) {
+        return envMapSchema.parse({});
+    }
+    const lines = match[0]
+        .split('\n')
+        .slice(1, -1)
+        .filter(Boolean);
+    return envMapSchema.parse(Object.fromEntries(lines.map((line) => {
+        if (line.startsWith('set -gx ')) {
+            const [, key, value] = line.match(/^set -gx ([A-Z0-9_]+) "(.*)"$/) ?? [];
+            return [key, value];
+        }
+        const [, key, value] = line.match(/^export ([A-Z0-9_]+)="(.*)"$/) ?? [];
+        return [key, value];
+    })));
+}
+function renderBlock(shell, env) {
+    const lines = Object.entries(env)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => shell === 'fish' ? `set -gx ${key} "${value}"` : `export ${key}="${value}"`);
+    return [startMarker, ...lines, endMarker, ''].join('\n');
+}
+function replaceManagedBlock(content, block) {
+    const pattern = /# >>> cc-env >>>[\s\S]*?# <<< cc-env <<<\n?/;
+    if (pattern.test(content)) {
+        const result = content.replace(pattern, block);
+        if (block === '') {
+            return result.replace(/\n{3,}/g, '\n\n').replace(/\n{2,}$/, '\n');
+        }
+        return result;
+    }
+    return content.length === 0 ? block : `${content.replace(/\n?$/, '\n')}\n${block}`;
+}
+export function createShellEnvService({ homeDir } = {}) {
+    const paths = resolveShellConfigPaths(homeDir);
+    async function readContent(path) {
+        try {
+            return await readFile(path, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return '';
+            }
+            throw error;
+        }
+    }
+    return {
+        async write(env) {
+            return Promise.all(Object.entries(paths).map(async ([shell, filePath]) => {
+                const content = await readContent(filePath);
+                const mergedEnv = envMapSchema.parse({
+                    ...parseManagedEnv(content),
+                    ...env,
+                });
+                await atomicWriteFile(filePath, replaceManagedBlock(content, renderBlock(shell, mergedEnv)));
+                return { shell, filePath, env: mergedEnv };
+            }));
+        },
+        async removeKeys(shellWrites, keys) {
+            await Promise.all(shellWrites.map(async ({ shell, filePath }) => {
+                const content = await readContent(filePath);
+                const current = parseManagedEnv(content);
+                const next = envMapSchema.parse(Object.fromEntries(Object.entries(current).filter(([key]) => !keys.includes(key))));
+                const block = Object.keys(next).length === 0 ? '' : renderBlock(shell, next);
+                await atomicWriteFile(filePath, replaceManagedBlock(content, block));
+            }));
+        },
+    };
+}

package/docs/product-specs/index.draft.md

@@ -0,0 +1,106 @@
+# 从零开始构建一个基于 nodejs 的命令行工具
+
+## 背景
+
+claude code cli 在启动的时候，会读取环境变量中需要的配置，以作为启动参数，比如模型的基础请求地址：ANTHROPIC_BASE_URL。这些配置一般定义在 ~/.claude/settings.json 中的 env 字段。
+现在有一个痛点，比如我有多家模型提供商，如果将配置写在 ~/.claude/settings.json 中，那么只能同时使用一家模型提供商，因此需要提供另外一种方式，让 claude code 在启动的时候可以指定提供商或者其他所有 claude code 支持的环境变量。
+
+## 功能描述
+
+### 使用方式
+
+在终端命令行下，提供一种如下的调用方式来启动 claude code：
+
+```bash
+cc-env --preset=some-preset claude
+```
+
+运行后 cc-env 会将 some-preset（提前设置过的） 对应的一组预置的环境变量（claude code 支持），让 claude code 读到运行时配置。
+
+### 初始化
+
+使用 cc-env 进行初始化，主要做的是将 ~/.claude/settings.json 中 env 的字段，移动到全局环境变量中，调用后展示 env 中已经定义的环境变量，默认勾选中以下字段：
+
+- ANTHROPIC_AUTH_TOKEN
+- ANTHROPIC_BASE_URL
+- ANTHROPIC_DEFAULT_HAIKU_MODEL
+- ANTHROPIC_DEFAULT_OPUS_MODEL
+- ANTHROPIC_DEFAULT_SONNET_MODEL
+- ANTHROPIC_REASONING_MODEL
+
+```bash
+cc-env --init // or cc-env -i
+```
+
+初始化移动过的记录需要保存在 ~/.cc-env 文件夹中，每一次初始化都要记录，以便恢复的时候，可以让用户选择。
+
+初始化可以重复执行，如果有字段覆盖，需要提示用户确认，一定要用户输入 Y 确认。
+
+### 恢复
+
+将初始化的移动的环境变量移动回 ~/.claude/settings.json 中 env 内。
+
+通过文件夹的方式展示每一次初始化记录和对应的字段给用户查看，左边栏是时间（从上到下，倒叙），右边栏是涉及变动的字段。用户选中确认后，按 Y 确认回写。
+
+### 创建预设
+
+参数你根据最合适的方式定义。
+
+预设默认放置在 ~/.cc-env 文件夹中，但是可以指定到当前文件夹下，如果是当前文件夹下，则自动创建 .cc-env 目录，并存放为 env.json，重复存放覆盖。
+
+#### 展示预设列表
+
+通过文件夹的方式展示所有预设，左边栏是时间（从上到下，倒叙），右边栏是对应的环境变量字段。
+
+#### 文件导入
+
+支持指定 claude code settings.json 文件路径，但是只会读取里面的 env 字段。
+
+支持 yaml 格式的文件，支持 json。
+
+限制：只支持 value 字段为非嵌套对象的输入，自动忽略不合法的值
+
+#### 交互式导入
+
+支持直接贴多行的 yaml 的输入和 json 输入。
+
+限制：只支持 value 字段为非嵌套对象的输入，自动忽略不合法的值
+
+#### 勾选时设置
+
+基于 claude code 官方支持 env，让用户勾选需要设置的环境变量值，确认依次录入具体的值，默认勾选中以下字段：
+
+- ANTHROPIC_AUTH_TOKEN
+- ANTHROPIC_BASE_URL
+- ANTHROPIC_DEFAULT_HAIKU_MODEL
+- ANTHROPIC_DEFAULT_OPUS_MODEL
+- ANTHROPIC_DEFAULT_SONNET_MODEL
+- ANTHROPIC_REASONING_MODEL
+
+限制：只支持 value 字段为非嵌套对象的输入，自动忽略不合法的值
+
+#### 删除预设
+
+参数你根据最合适的方式定义。
+
+展示预设列表，选中确认后，输入 Y 删除
+
+#### 编辑预设
+
+参数你根据最合适的方式定义。
+
+交互方式你来定。
+
+#### 读取目录下的预设
+
+cc-env 在启动时候，检查当前目录下 .cc-env/env.json 或者 .cc-env/env.yaml，如果存在，则当作较高优先级的环境变量使用。
+
+## 要求
+
+### 技术栈
+
+基于 nodejs 为 base，选用最佳的 cli 实现技术栈
+
+## 引用
+
+### [claude code 官方支持 env](../references/claude-code-env.md)