aicodeswitch 3.9.4 → 4.0.0

package/bin/utils/config-helpers.js

@@ -0,0 +1,198 @@
+const fs = require('fs');
+const path = require('path');
+const toml = require('@iarna/toml');
+
+/**
+ * TOML 解析器
+ */
+const parseToml = (content) => {
+  try {
+    return toml.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to parse TOML: ${error.message}`);
+  }
+};
+
+/**
+ * TOML 序列化器
+ */
+const stringifyToml = (obj) => {
+  try {
+    return toml.stringify(obj);
+  } catch (error) {
+    throw new Error(`Failed to stringify TOML: ${error.message}`);
+  }
+};
+
+/**
+ * 深拷贝
+ */
+const deepClone = (value) => JSON.parse(JSON.stringify(value));
+
+/**
+ * 判断字段路径是否被管理（支持前缀匹配）
+ */
+const isManagedPath = (fieldPath, managedFields) => {
+  return managedFields.some((managedField) => {
+    const managedPath = managedField.split('.');
+    if (fieldPath.length < managedPath.length) {
+      return false;
+    }
+
+    for (let i = 0; i < managedPath.length; i += 1) {
+      if (String(fieldPath[i]) !== managedPath[i]) {
+        return false;
+      }
+    }
+    return true;
+  });
+};
+
+/**
+ * 深度获取对象值
+ */
+const deepGet = (obj, fieldPath) => {
+  let current = obj;
+  for (const segment of fieldPath) {
+    if (current === undefined || current === null) {
+      return undefined;
+    }
+    current = current[segment];
+  }
+  return current;
+};
+
+/**
+ * 深度设置对象值
+ */
+const deepSet = (obj, fieldPath, value) => {
+  let current = obj;
+  for (let i = 0; i < fieldPath.length - 1; i += 1) {
+    const key = fieldPath[i];
+    if (current[key] === undefined || current[key] === null || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[fieldPath[fieldPath.length - 1]] = value;
+};
+
+/**
+ * 收集所有叶子字段路径（数组视为叶子）
+ */
+const collectPaths = (obj, currentPath = [], allPaths = []) => {
+  if (obj === null || obj === undefined) {
+    if (currentPath.length > 0) {
+      allPaths.push(currentPath);
+    }
+    return allPaths;
+  }
+
+  if (Array.isArray(obj)) {
+    if (currentPath.length > 0) {
+      allPaths.push(currentPath);
+    }
+    return allPaths;
+  }
+
+  if (typeof obj !== 'object') {
+    if (currentPath.length > 0) {
+      allPaths.push(currentPath);
+    }
+    return allPaths;
+  }
+
+  const keys = Object.keys(obj);
+  if (keys.length === 0) {
+    if (currentPath.length > 0) {
+      allPaths.push(currentPath);
+    }
+    return allPaths;
+  }
+
+  for (const key of keys) {
+    collectPaths(obj[key], [...currentPath, key], allPaths);
+  }
+
+  return allPaths;
+};
+
+/**
+ * JSON 合并函数
+ * 以 source 为基础，合并 other 中的非管理字段
+ */
+const mergeJsonSettings = (source, other, managedFields) => {
+  const result = deepClone(source);
+  const allPaths = collectPaths(other);
+
+  for (const fieldPath of allPaths) {
+    if (isManagedPath(fieldPath, managedFields)) {
+      continue;
+    }
+
+    const value = deepGet(other, fieldPath);
+    if (value !== undefined) {
+      deepSet(result, fieldPath, deepClone(value));
+    }
+  }
+
+  return result;
+};
+
+/**
+ * TOML 合并函数
+ * 以 source 为基础，合并 other 中的非管理字段
+ */
+const mergeTomlSettings = (source, other, managedFields) => {
+  const result = deepClone(source);
+  const allPaths = collectPaths(other);
+
+  for (const fieldPath of allPaths) {
+    if (isManagedPath(fieldPath, managedFields)) {
+      continue;
+    }
+
+    const value = deepGet(other, fieldPath);
+    if (value !== undefined) {
+      deepSet(result, fieldPath, deepClone(value));
+    }
+  }
+
+  return result;
+};
+
+/**
+ * 原子性写入函数
+ * 先写入临时文件，然后原子性重命名
+ */
+const atomicWriteFile = (filePath, content) => {
+  const tempFile = path.join(path.dirname(filePath), `.tmp_${path.basename(filePath)}`);
+
+  try {
+    // 确保目录存在
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // 写入临时文件
+    fs.writeFileSync(tempFile, content, 'utf-8');
+
+    // 原子性重命名
+    fs.renameSync(tempFile, filePath);
+  } catch (error) {
+    // 清理临时文件
+    if (fs.existsSync(tempFile)) {
+      fs.unlinkSync(tempFile);
+    }
+    throw error;
+  }
+};
+
+module.exports = {
+  parseToml,
+  stringifyToml,
+  mergeJsonSettings,
+  mergeTomlSettings,
+  atomicWriteFile,
+};

package/dist/server/config-managed-fields.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManagedFields = exports.CODEX_AUTH_MANAGED_FIELDS = exports.CODEX_CONFIG_MANAGED_FIELDS = exports.CLAUDE_JSON_MANAGED_FIELDS = exports.CLAUDE_SETTINGS_MANAGED_FIELDS = void 0;
+/**
+ * Claude Code settings.json 管理字段定义
+ */
+exports.CLAUDE_SETTINGS_MANAGED_FIELDS = [
+    { path: ['env', 'ANTHROPIC_AUTH_TOKEN'] },
+    { path: ['env', 'ANTHROPIC_BASE_URL'] },
+    { path: ['env', 'API_TIMEOUT_MS'] },
+    { path: ['env', 'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC'] },
+    { path: ['env', 'CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS'], optional: true },
+    { path: ['env', 'ANTHROPIC_DEFAULT_HAIKU_MODEL'], optional: true },
+    { path: ['env', 'ANTHROPIC_DEFAULT_SONNET_MODEL'], optional: true },
+    { path: ['env', 'ANTHROPIC_DEFAULT_OPUS_MODEL'], optional: true },
+    { path: ['permissions'], optional: true },
+    { path: ['skipDangerousModePermissionPrompt'], optional: true },
+    { path: ['effortLevel'], optional: true },
+    { path: ['model'], optional: true },
+];
+/**
+ * Claude Code .claude.json 管理字段定义
+ */
+exports.CLAUDE_JSON_MANAGED_FIELDS = [
+    { path: ['hasCompletedOnboarding'] },
+    { path: ['mcpServers'], optional: true },
+];
+/**
+ * Codex config.toml 管理字段定义
+ */
+exports.CODEX_CONFIG_MANAGED_FIELDS = [
+    { path: ['model_provider'] },
+    { path: ['model'] },
+    { path: ['model_reasoning_effort'] },
+    { path: ['disable_response_storage'] },
+    { path: ['preferred_auth_method'] },
+    { path: ['requires_openai_auth'] },
+    { path: ['enableRouteSelection'] },
+    { path: ['model_providers', 'aicodeswitch'], isSection: true },
+];
+/**
+ * Codex auth.json 管理字段定义
+ */
+exports.CODEX_AUTH_MANAGED_FIELDS = [
+    { path: ['OPENAI_API_KEY'] },
+];
+/**
+ * 根据配置类型和文件路径获取管理字段列表
+ */
+const getManagedFields = (configType, filePath) => {
+    if (configType === 'claude') {
+        if (filePath.endsWith('settings.json')) {
+            return exports.CLAUDE_SETTINGS_MANAGED_FIELDS;
+        }
+        else if (filePath.endsWith('.claude.json')) {
+            return exports.CLAUDE_JSON_MANAGED_FIELDS;
+        }
+    }
+    else if (configType === 'codex') {
+        if (filePath.endsWith('config.toml')) {
+            return exports.CODEX_CONFIG_MANAGED_FIELDS;
+        }
+        else if (filePath.endsWith('auth.json')) {
+            return exports.CODEX_AUTH_MANAGED_FIELDS;
+        }
+    }
+    return [];
+};
+exports.getManagedFields = getManagedFields;

package/dist/server/config-merge.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeWriteConfig = exports.atomicWriteFile = exports.mergeTomlConfig = exports.stringifyToml = exports.parseToml = exports.mergeJsonConfig = exports.isFieldManaged = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const toml_1 = __importDefault(require("@iarna/toml"));
+/**
+ * 判断字段路径是否匹配
+ * @param fieldPath 要检查的字段路径
+ * @param managedPath 管理字段路径定义
+ * @returns 是否匹配
+ */
+const pathMatches = (fieldPath, managedPath) => {
+    if (fieldPath.length < managedPath.length) {
+        return false;
+    }
+    for (let i = 0; i < managedPath.length; i++) {
+        const fieldKey = fieldPath[i];
+        const managedKey = managedPath[i];
+        // 如果管理字段是通配符（数字索引），则匹配任何数字
+        if (typeof managedKey === 'number') {
+            if (typeof fieldKey !== 'number') {
+                return false;
+            }
+        }
+        else if (fieldKey !== managedKey) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * 判断字段是否被管理
+ * @param fieldPath 字段路径
+ * @param managedFields 管理字段列表
+ * @returns 是否被管理
+ */
+const isFieldManaged = (fieldPath, managedFields) => {
+    for (const managed of managedFields) {
+        if (pathMatches(fieldPath, managed.path)) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.isFieldManaged = isFieldManaged;
+/**
+ * 递归遍历对象，收集叶子字段路径
+ * @param obj 要遍历的对象
+ * @param currentPath 当前路径
+ * @param allPaths 收集所有路径的数组
+ */
+const collectPaths = (obj, currentPath, allPaths) => {
+    // 基础类型/null：当前路径即叶子
+    if (obj === null || obj === undefined || typeof obj !== 'object') {
+        if (currentPath.length > 0) {
+            allPaths.push(currentPath);
+        }
+        return;
+    }
+    // 数组：递归收集元素叶子；空数组本身视为叶子
+    if (Array.isArray(obj)) {
+        if (obj.length === 0) {
+            if (currentPath.length > 0) {
+                allPaths.push(currentPath);
+            }
+            return;
+        }
+        obj.forEach((item, index) => {
+            collectPaths(item, [...currentPath, index], allPaths);
+        });
+        return;
+    }
+    // 对象：递归收集子字段；空对象本身视为叶子
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+        if (currentPath.length > 0) {
+            allPaths.push(currentPath);
+        }
+        return;
+    }
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            collectPaths(obj[key], [...currentPath, key], allPaths);
+        }
+    }
+};
+/**
+ * 深度获取对象的值
+ * @param obj 目标对象
+ * @param path 字段路径
+ * @returns 字段值
+ */
+const deepGet = (obj, path) => {
+    let current = obj;
+    for (const key of path) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+};
+/**
+ * 深度设置对象的值
+ * @param obj 目标对象
+ * @param path 字段路径
+ * @param value 要设置的值
+ */
+const deepSet = (obj, path, value) => {
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (current[key] === undefined || current[key] === null || typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    current[path[path.length - 1]] = value;
+};
+/**
+ * 合并 JSON 配置
+ * @param source 源配置（包含管理字段）
+ * @param other 其他配置（包含非管理字段）
+ * @param managedFields 管理字段列表
+ * @returns 合并后的配置
+ */
+const mergeJsonConfig = (source, other, managedFields) => {
+    // 复制源配置作为基础
+    const result = JSON.parse(JSON.stringify(source));
+    // 收集 other 中所有的字段路径
+    const allPaths = [];
+    collectPaths(other, [], allPaths);
+    // 对于每个路径，如果不是管理字段，则从 other 中复制到 result
+    for (const fieldPath of allPaths) {
+        if (!(0, exports.isFieldManaged)(fieldPath, managedFields)) {
+            const value = deepGet(other, fieldPath);
+            deepSet(result, fieldPath, value);
+        }
+    }
+    return result;
+};
+exports.mergeJsonConfig = mergeJsonConfig;
+/**
+ * 解析 TOML 配置文件
+ * @param content TOML 内容
+ * @returns 解析后的对象
+ */
+const parseToml = (content) => {
+    try {
+        return toml_1.default.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse TOML: ${error}`);
+    }
+};
+exports.parseToml = parseToml;
+/**
+ * 序列化对象为 TOML 格式
+ * @param obj 要序列化的对象
+ * @returns TOML 字符串
+ */
+const stringifyToml = (obj) => {
+    // 使用 @iarna/toml 库的 stringify 方法
+    try {
+        return toml_1.default.stringify(obj);
+    }
+    catch (error) {
+        throw new Error(`Failed to stringify TOML: ${error}`);
+    }
+};
+exports.stringifyToml = stringifyToml;
+/**
+ * 合并 TOML 配置
+ * @param source 源配置（包含管理字段）
+ * @param other 其他配置（包含非管理字段）
+ * @param managedFields 管理字段列表
+ * @returns 合并后的配置
+ */
+const mergeTomlConfig = (source, other, managedFields) => {
+    // 复制源配置作为基础
+    const result = JSON.parse(JSON.stringify(source));
+    // 收集 other 中所有的字段路径
+    const allPaths = [];
+    collectPaths(other, [], allPaths);
+    // 对于每个路径，如果不是管理字段，则从 other 中复制到 result
+    for (const fieldPath of allPaths) {
+        if (!(0, exports.isFieldManaged)(fieldPath, managedFields)) {
+            const value = deepGet(other, fieldPath);
+            deepSet(result, fieldPath, value);
+        }
+    }
+    return result;
+};
+exports.mergeTomlConfig = mergeTomlConfig;
+/**
+ * 原子性写入文件
+ * 先写入临时文件，然后重命名，确保写入失败时不会损坏原文件
+ * @param filePath 目标文件路径
+ * @param content 要写入的内容
+ */
+const atomicWriteFile = (filePath, content) => {
+    const dir = path_1.default.dirname(filePath);
+    const tempFile = path_1.default.join(dir, `.tmp_${path_1.default.basename(filePath)}`);
+    try {
+        // 确保目录存在
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        // 写入临时文件
+        fs_1.default.writeFileSync(tempFile, content, 'utf-8');
+        // 原子性重命名
+        fs_1.default.renameSync(tempFile, filePath);
+    }
+    catch (error) {
+        // 清理临时文件
+        if (fs_1.default.existsSync(tempFile)) {
+            fs_1.default.unlinkSync(tempFile);
+        }
+        throw error;
+    }
+};
+exports.atomicWriteFile = atomicWriteFile;
+/**
+ * 带回退的安全写入
+ * 如果写入失败，恢复原文件
+ * @param filePath 目标文件路径
+ * @param content 要写入的内容
+ * @returns 是否成功
+ */
+const safeWriteConfig = (filePath, content) => {
+    let originalContent = null;
+    try {
+        // 如果原文件存在，读取其内容
+        if (fs_1.default.existsSync(filePath)) {
+            originalContent = fs_1.default.readFileSync(filePath, 'utf-8');
+        }
+        // 原子性写入新内容
+        (0, exports.atomicWriteFile)(filePath, content);
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to write ${filePath}:`, error);
+        // 如果写入失败且原文件存在，恢复原文件
+        if (originalContent !== null && !fs_1.default.existsSync(filePath)) {
+            try {
+                fs_1.default.writeFileSync(filePath, originalContent, 'utf-8');
+                console.log(`Restored ${filePath} from backup`);
+            }
+            catch (restoreError) {
+                console.error(`Failed to restore ${filePath}:`, restoreError);
+            }
+        }
+        return false;
+    }
+};
+exports.safeWriteConfig = safeWriteConfig;