ccman 3.0.14 → 3.0.16

package/README.md

@@ -1,371 +1,296 @@
 # ccman
 
-> Codex 和 Claude Code 的 API 服务商配置管理工具
+> Codex 和 Claude Code 的 API 服务商配置管理工具，一键切换 Codex 和 Claude Code 的 API 服务商配置。
 
-## ✨ 特性
+---
 
-- 🔄 **快速切换**：一键切换不同的 API 服务商
-- 📦 **预设模板**：内置 7 个常用服务商模板，只需填写 API Key
-- 🛠️ **灵活配置**：支持自定义服务商配置
-- 🔒 **安全存储**：API Key 只存储在本地，权限保护
+## ✨ 核心特性
+
+- 🔄 **一键切换**：一条命令切换服务商，自动修改配置文件
+- 📦 **内置预设**：7 个常用服务商模板，只需填写 API Key
+- 🛠️ **自定义配置**：支持添加任意第三方服务商
+- 🔐 **零破坏性**：只修改管理的字段，写入前备份，失败回滚
 - 🎯 **双工具支持**：同时管理 Codex 和 Claude Code
+- 📱 **双界面**：提供 CLI（命令行）和 Desktop（图形界面）
+- 🔁 **克隆功能**：快速复制配置，管理多个 API Key
+- ☁️ **WebDAV 同步**（可选）：同步配置到你自己的 WebDAV 服务器（iCloud/Dropbox）
+- 🔒 **无第三方上传**：不会上传到我们的服务器，配置权限 `0600`
+- 🎨 **交互式菜单**：无需记忆命令，跟随提示操作
 
-## 📦 安装
+---
 
-```bash
-npm install -g ccman
-```
+## 也许你不需要 ccman
 
-**系统要求**：Node.js >= 18.0.0
+ccman 的核心功能是自动化配置文件的切换：
 
-## 🚀 快速开始
+- **Codex**：自动修改 `~/.codex/config.toml` 和 `~/.codex/auth.json`
+- **Claude Code**：自动修改 `~/.claude/settings.json`
+- **备份机制**：写入前自动备份，失败时自动回滚
 
-### 管理 Codex 服务商
+如果你更喜欢手动编辑配置文件，或者只使用一个服务商从不切换，可能不需要这个工具。
 
-```bash
-# 1. 添加服务商（交互式）
-ccman cx add
+📖 更多信息：[GitHub 仓库](https://github.com/2ue/ccm) - 包含手动配置方式和详细对比分析
 
-# 2. 查看所有服务商
-ccman cx list
+---
 
-# 3. 切换服务商
-ccman cx use
-
-# 4. 查看当前服务商
-ccman cx current
-```
-
-### 管理 Claude Code 服务商
+## 安装
 
 ```bash
-# 1. 添加服务商（交互式）
-ccman cc add
+npm install -g ccman
+```
 
-# 2. 查看所有服务商
-ccman cc list
+**要求**：Node.js >= 18.0.0
 
-# 3. 切换服务商
-ccman cc use
+**Desktop 版本**：如果你更喜欢图形界面，可以从 [GitHub Releases](https://github.com/2ue/ccm/releases) 下载 Desktop 应用（macOS/Windows/Linux）。
 
-# 4. 查看当前服务商
-ccman cc current
-```
+---
 
-### 交互式菜单
+## 快速开始
 
-直接运行 `ccman` 进入交互式主菜单：
+### 查看帮助
 
 ```bash
-ccman         # 主菜单（选择 Codex 或 Claude Code）
-ccman cx      # Codex 菜单
-ccman cc      # Claude Code 菜单
-```
+$ ccman --help
 
-## 📚 命令详解
+Usage: ccman [options] [command]
 
-### Codex 命令（`ccman cx`）
+Codex/Claude Code API 服务商配置管理工具
 
-#### `ccman cx add`
+Options:
+  -V, --version   output the version number
+  -h, --help      display help for command
 
-添加新的 Codex 服务商。
+Commands:
+  cx              管理 Codex 服务商
+  cc              管理 Claude 服务商
+  sync            WebDAV 同步配置
+  help [command]  display help for command
+```
 
-**交互流程**：
+### 管理 Codex 服务商
 
 ```bash
-$ ccman cx add
-
-? 选择配置方式 ›
-❯ 使用预设模板
-  自定义配置
-
-# 选择 "使用预设模板"
-? 选择预设 ›
-❯ Anthropic Official
-  AnyRouter
-  PackyCode
-  CoordCode
-  88Code
-  BigModel
-  ModelScope
-
-# 填写信息
-? 服务商名称 › Anthropic Official
-? API Key › sk-ant-••••••••••••••••••••••
-
-✅ 添加成功！
-💡 切换到此服务商: ccman cx use "Anthropic Official"
+ccman cx           # 进入交互式菜单
+ccman cx add       # 添加服务商
+ccman cx use       # 切换服务商
+ccman cx list      # 查看所有服务商
 ```
 
-#### `ccman cx list`
-
-列出所有 Codex 服务商，`●` 表示当前使用的服务商。
+**示例输出**：
 
 ```bash
 $ ccman cx list
 
-📋 Codex 服务商列表 (共 2 个)
+📋 Codex 服务商 (2 个)
 
-● Anthropic Official
-  https://api.anthropic.com
+  ●  Anthropic Official [当前]
+     https://api.anthropic.com
 
-○ PackyCode
-  https://api.packycode.com
+  ○  88Code
+     https://www.88code.org/api
 ```
 
-#### `ccman cx use [name]`
-
-切换 Codex 服务商。如果不提供名称，会显示交互式选择器。
-
 ```bash
-# 交互式选择
-$ ccman cx use
-
-? 选择要使用的服务商 ›
-  Anthropic Official (当前)
-❯ PackyCode
+$ ccman cx current
 
-✅ 已切换到: PackyCode
+📍 当前 Codex 服务商
 
-# 直接指定名称
-$ ccman cx use PackyCode
-✅ 已切换到: PackyCode
+  Anthropic Official
+  ID: codex-1760178741529-hbgbad
+  URL: https://api.anthropic.com
+  最后使用: 2025/10/11 18:32:25
 ```
 
-**说明**：切换后会自动更新 `~/.codex/` 中的配置文件，无需重启 Codex。
-
-#### `ccman cx current`
-
-显示当前使用的 Codex 服务商。
+### 管理 Claude Code 服务商
 
 ```bash
-$ ccman cx current
-
-✅ 当前 Codex 服务商
-
-名称: PackyCode
-Base URL: https://api.packycode.com
-API Key: sk-••••••••••••••••••••••••••••••••
+ccman cc           # 进入交互式菜单
+ccman cc add       # 添加服务商
+ccman cc use       # 切换服务商
+ccman cc list      # 查看所有服务商
 ```
 
-#### `ccman cx edit [name]`
-
-编辑 Codex 服务商配置。
+**示例输出**：
 
 ```bash
-$ ccman cx edit
+$ ccman cc list
 
-? 选择要编辑的服务商 ›
-❯ Anthropic Official
-  PackyCode
+📋 Claude Code 服务商 (2 个)
 
-# 选择后可以修改
-? 服务商名称 › Anthropic Official
-? Base URL › https://api.anthropic.com
-? API Key › (留空保持不变)
+  ○  AnyRouter
+     https://anyrouter.top
 
-✅ 编辑成功！
+  ●  PackyCode [当前]
+     https://api.packycode.com
 ```
 
-#### `ccman cx remove [name]`
-
-删除 Codex 服务商。
-
 ```bash
-$ ccman cx remove
-
-? 选择要删除的服务商 ›
-  Anthropic Official (当前使用中)
-❯ PackyCode
+$ ccman cc current
 
-? 确认删除 "PackyCode"? › (y/N)
+📍 当前 Claude Code 服务商
 
-✅ 已删除: PackyCode
+  PackyCode
+  ID: claude-1760182672751-unh2bp
+  URL: https://api.packycode.com
+  最后使用: 2025/10/11 20:14:08
 ```
 
-#### `ccman cx clone [source]`
+---
 
-克隆 Codex 服务商配置（复制 Base URL，修改名称和 API Key）。
+## 完整命令
 
-```bash
-$ ccman cx clone
+| 命令 | 说明 |
+|------|------|
+| `ccman` | 主菜单（选择 Codex 或 Claude Code） |
+| `ccman cx` | Codex 交互式菜单 |
+| `ccman cx add` | 添加 Codex 服务商（支持预设模板和自定义） |
+| `ccman cx list` | 列出所有 Codex 服务商 |
+| `ccman cx use [name]` | 切换 Codex 服务商 |
+| `ccman cx current` | 查看当前 Codex 服务商 |
+| `ccman cx edit [name]` | 编辑 Codex 服务商 |
+| `ccman cx remove [name]` | 删除 Codex 服务商 |
+| `ccman cx clone [source]` | 克隆 Codex 服务商（复制配置，改名称和 Key） |
+| `ccman cc` | Claude Code 交互式菜单 |
+| `ccman cc add` | 添加 Claude Code 服务商 |
+| `ccman cc list` | 列出所有 Claude Code 服务商 |
+| `ccman cc use [name]` | 切换 Claude Code 服务商 |
+| `ccman cc current` | 查看当前 Claude Code 服务商 |
+| `ccman cc edit [name]` | 编辑 Claude Code 服务商 |
+| `ccman cc remove [name]` | 删除 Claude Code 服务商 |
+| `ccman cc clone [source]` | 克隆 Claude Code 服务商 |
+| `ccman sync` | WebDAV 同步配置（备份/恢复/合并） |
 
-? 选择要克隆的服务商 ›
-❯ Anthropic Official
-  PackyCode
+---
 
-? 新服务商名称 › Anthropic Test
-? API Key › sk-ant-test-••••••••••••••••••
+## 内置预设
 
-✅ 克隆成功！
-💡 切换到此服务商: ccman cx use "Anthropic Test"
-```
-
-**使用场景**：
-- 同一服务商有多个 API Key（测试/生产环境）
-- 快速创建类似配置的服务商
-
-### Claude Code 命令（`ccman cc`）
+添加服务商时可以选择"使用预设模板"，只需填写 API Key：
 
-Claude Code 的命令与 Codex 完全相同：
+| 预设名称 | Base URL |
+|---------|----------|
+| Anthropic Official | `https://api.anthropic.com` |
+| AnyRouter | `https://anyrouter.top` |
+| PackyCode | `https://api.packycode.com` |
+| CoordCode | `https://api.coordcode.com/api` |
+| 88Code | `https://www.88code.org/api` |
+| BigModel | `https://open.bigmodel.cn/api/anthropic` |
+| ModelScope | `https://api-inference.modelscope.cn/v1/chat/completions` |
 
-- `ccman cc add` - 添加服务商
-- `ccman cc list` - 列出服务商
-- `ccman cc use [name]` - 切换服务商
-- `ccman cc current` - 查看当前服务商
-- `ccman cc edit [name]` - 编辑服务商
-- `ccman cc remove [name]` - 删除服务商
-- `ccman cc clone [source]` - 克隆服务商
+也可以选择"自定义配置"，手动填写 Base URL。
 
-**说明**：切换后会自动更新 `~/.claude/settings.json`，无需重启 Claude Code。
+---
 
-## 🎨 内置预设模板
+## 完整使用示例
 
-两个工具都支持以下预设（只需填写 API Key）：
+### 场景 1：添加并切换服务商
 
-| 预设名称 | Base URL | 说明 |
-|---------|----------|------|
-| Anthropic Official | `https://api.anthropic.com` | Anthropic 官方 API |
-| AnyRouter | `https://anyrouter.top` | AnyRouter API 服务 |
-| PackyCode | `https://api.packycode.com` | PackyCode API 服务 |
-| CoordCode | `https://api.coordcode.com/api` | CoordCode API 服务 |
-| 88Code | `https://www.88code.org/api` | 88Code API 服务 |
-| BigModel | `https://open.bigmodel.cn/api/anthropic` | 智谱 BigModel API |
-| ModelScope | `https://api-inference.modelscope.cn/v1/chat/completions` | 阿里云 ModelScope API |
+```bash
+# 1. 查看当前列表
+$ ccman cx list
 
-## 💡 使用示例
+📋 Codex 服务商 (1 个)
 
-### 示例 1：添加并切换到新服务商
+  ●  Anthropic Official [当前]
+     https://api.anthropic.com
 
-```bash
-# 1. 添加 PackyCode
+# 2. 添加 PackyCode（交互式）
 $ ccman cx add
-# 选择 "使用预设模板" → "PackyCode" → 输入 API Key
+? 选择配置方式 › 使用预设模板
+? 选择预设 › PackyCode
+? 服务商名称 › PackyCode
+? API Key › ••••••••••••••••••••
+✅ 添加成功！
+💡 切换到此服务商: ccman cx use PackyCode
 
-# 2. 切换到 PackyCode
+# 3. 切换到 PackyCode
 $ ccman cx use PackyCode
 ✅ 已切换到: PackyCode
 
-# 3. 确认
+# 4. 确认当前服务商
 $ ccman cx current
-✅ 当前 Codex 服务商
-名称: PackyCode
+
+📍 当前 Codex 服务商
+
+  PackyCode
+  ID: codex-1760178741529-abc123
+  URL: https://api.packycode.com
+  最后使用: 2025/10/11 18:32:25
 ```
 
-### 示例 2：管理多个 API Key
+### 场景 2：克隆服务商（管理多个 Key）
 
 ```bash
-# 场景：同一服务商有测试和生产两个 API Key
-
 # 1. 添加生产配置
 $ ccman cc add
-# 名称: Claude Production
-# API Key: sk-ant-prod-xxx
+? 选择配置方式 › 自定义配置
+? 服务商名称 › Claude Production
+? Base URL › https://api.anthropic.com
+? API Key › ••••••••••••••••••••
+✅ 添加成功！
 
 # 2. 克隆创建测试配置
 $ ccman cc clone
-# 选择 "Claude Production"
-# 新名称: Claude Test
-# API Key: sk-ant-test-xxx
+? 选择要克隆的服务商 › Claude Production
+? 新服务商名称 › Claude Test
+? API Key › ••••••••••••••••••••
+✅ 克隆成功！
+💡 切换到此服务商: ccman cc use "Claude Test"
 
 # 3. 查看列表
 $ ccman cc list
-📋 Claude Code 服务商列表 (共 2 个)
-● Claude Production (当前)
-○ Claude Test
 
-# 4. 快速切换
-$ ccman cc use "Claude Test"
-✅ 已切换到: Claude Test
-```
+📋 Claude Code 服务商 (2 个)
 
-### 示例 3：自定义服务商配置
+  ●  Claude Production [当前]
+     https://api.anthropic.com
 
-```bash
-$ ccman cx add
-
-? 选择配置方式 › 自定义配置
-? 服务商名称 › My Custom Provider
-? Base URL › https://api.example.com/v1
-? API Key › my-secret-key
-
-✅ 添加成功！
-```
+  ○  Claude Test
+     https://api.anthropic.com
 
-## 📂 配置文件
-
-### ccman 配置
-
-**位置**：`~/.ccman/config.json`
-
-**结构**：
-
-```json
-{
-  "providers": [
-    {
-      "id": "codex-1234567890-abc123",
-      "name": "PackyCode",
-      "type": "codex",
-      "baseUrl": "https://api.packycode.com",
-      "apiKey": "sk-xxx",
-      "createdAt": 1234567890000,
-      "lastUsedAt": 1234567900000
-    }
-  ],
-  "currentCodexProvider": "codex-1234567890-abc123",
-  "currentClaudeProvider": null
-}
+# 4. 快速切换
+$ ccman cc use "Claude Test"
+✅ 已切换到: Claude Test
 ```
 
-### Codex 配置
-
-ccman 会自动修改以下文件：
-
-- `~/.codex/config.toml` - Codex 主配置
-- `~/.codex/auth.json` - 认证信息
-
-### Claude Code 配置
-
-ccman 会自动修改以下文件：
-
-- `~/.claude/settings.json` - Claude Code 设置（只修改 `env.ANTHROPIC_AUTH_TOKEN` 和 `env.ANTHROPIC_BASE_URL`，不影响其他配置）
-
-## 🔒 安全性
-
-- ✅ API Key 只存储在本地，不会联网上传
-- ✅ 配置文件设置为 `0600` 权限（仅当前用户可读写）
-- ✅ 终端输入 API Key 时自动隐藏（显示为 `••••`）
-- ✅ 列表显示时 API Key 自动脱敏
+---
 
-## ❓ 常见问题
+## 配置文件
 
-### Q: 如何切换回之前的服务商？
+**ccman 配置**：`~/.ccman/config.json`
 
-A: 使用 `ccman cx use` 或 `ccman cc use` 选择之前的服务商即可。
+**Codex 配置**（ccman 会自动修改）：
+- `~/.codex/config.toml`
+- `~/.codex/auth.json`
 
-### Q: 删除服务商后还能恢复吗？
+**Claude Code 配置**（ccman 会自动修改）：
+- `~/.claude/settings.json`
 
-A: 不能。删除操作不可逆，建议删除前确认。
+**零破坏性承诺**：
+- 只修改管理的字段，保留其他所有配置
+- 写入前备份，失败时自动回滚
+- API Key 存储在本地，权限 `0600`
 
-### Q: 可以同时使用 CLI 和 Desktop 吗？
+---
 
-A: 可以。未来会推出 Desktop 应用，CLI 和 Desktop 共享同一套配置文件（`~/.ccman/`），修改会实时同步。
+## 常见问题
 
-### Q: 切换服务商后需要重启 Codex/Claude Code 吗？
+**Q: 支持配置导入/导出吗？**
+A: 当前版本不支持。如需备份，手动复制 `~/.ccman/` 目录。
 
-A: 不需要。ccman 会直接修改配置文件，工具会自动重新加载配置。
+**Q: WebDAV 同步是什么？**
+A: 将 ccman 配置同步到 WebDAV 服务器（如 iCloud/Dropbox），多设备共享配置。详见 `ccman sync --help`。
 
-### Q: 支持导入/导出配置吗？
+---
 
-A: 当前版本不支持。如需备份配置，可以手动复制 `~/.ccman/` 目录。
+## 许可证
 
-## 📄 许可证
+MIT
 
-MIT © [2ue](https://github.com/2ue)
+---
 
-## 🔗 相关链接
+## 相关链接
 
 - [GitHub 仓库](https://github.com/2ue/ccm)
 - [问题反馈](https://github.com/2ue/ccm/issues)
 - [更新日志](https://github.com/2ue/ccm/blob/main/CHANGELOG.md)
+- [Desktop 版本](https://github.com/2ue/ccm/releases)（图形界面）

package/dist/index.js

@@ -39,7 +39,7 @@ var init_package = __esm({
   "../core/package.json"() {
     package_default = {
       name: "@ccman/core",
-      version: "3.0.14",
+      version: "3.0.16",
       type: "module",
       description: "Core business logic for ccman",
       main: "./dist/index.js",
@@ -3001,22 +3001,22 @@ var require_url_parse = __commonJS({
     }
     function resolve(relative, base) {
       if (relative === "") return base;
-      var path8 = (base || "/").split("/").slice(0, -1).concat(relative.split("/")), i2 = path8.length, last = path8[i2 - 1], unshift = false, up = 0;
+      var path11 = (base || "/").split("/").slice(0, -1).concat(relative.split("/")), i2 = path11.length, last = path11[i2 - 1], unshift = false, up = 0;
       while (i2--) {
-        if (path8[i2] === ".") {
-          path8.splice(i2, 1);
-        } else if (path8[i2] === "..") {
-          path8.splice(i2, 1);
+        if (path11[i2] === ".") {
+          path11.splice(i2, 1);
+        } else if (path11[i2] === "..") {
+          path11.splice(i2, 1);
           up++;
         } else if (up) {
           if (i2 === 0) unshift = true;
-          path8.splice(i2, 1);
+          path11.splice(i2, 1);
           up--;
         }
       }
-      if (unshift) path8.unshift("");
-      if (last === "." || last === "..") path8.push("");
-      return path8.join("/");
+      if (unshift) path11.unshift("");
+      if (last === "." || last === "..") path11.push("");
+      return path11.join("/");
     }
     function Url(address, location, parser) {
       address = trimLeft(address);
@@ -3442,14 +3442,14 @@ var require_path_posix = __commonJS({
     posix.resolve = function() {
       var resolvedPath = "", resolvedAbsolute = false;
       for (var i2 = arguments.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
-        var path8 = i2 >= 0 ? arguments[i2] : process.cwd();
-        if (!isString(path8)) {
+        var path11 = i2 >= 0 ? arguments[i2] : process.cwd();
+        if (!isString(path11)) {
           throw new TypeError("Arguments to path.resolve must be strings");
-        } else if (!path8) {
+        } else if (!path11) {
           continue;
         }
-        resolvedPath = path8 + "/" + resolvedPath;
-        resolvedAbsolute = path8.charAt(0) === "/";
+        resolvedPath = path11 + "/" + resolvedPath;
+        resolvedAbsolute = path11.charAt(0) === "/";
       }
       resolvedPath = normalizeArray(
         resolvedPath.split("/"),
@@ -3457,36 +3457,36 @@ var require_path_posix = __commonJS({
       ).join("/");
       return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
     };
-    posix.normalize = function(path8) {
-      var isAbsolute = posix.isAbsolute(path8), trailingSlash = path8.substr(-1) === "/";
-      path8 = normalizeArray(path8.split("/"), !isAbsolute).join("/");
-      if (!path8 && !isAbsolute) {
-        path8 = ".";
+    posix.normalize = function(path11) {
+      var isAbsolute = posix.isAbsolute(path11), trailingSlash = path11.substr(-1) === "/";
+      path11 = normalizeArray(path11.split("/"), !isAbsolute).join("/");
+      if (!path11 && !isAbsolute) {
+        path11 = ".";
       }
-      if (path8 && trailingSlash) {
-        path8 += "/";
+      if (path11 && trailingSlash) {
+        path11 += "/";
       }
-      return (isAbsolute ? "/" : "") + path8;
+      return (isAbsolute ? "/" : "") + path11;
     };
-    posix.isAbsolute = function(path8) {
-      return path8.charAt(0) === "/";
+    posix.isAbsolute = function(path11) {
+      return path11.charAt(0) === "/";
     };
     posix.join = function() {
-      var path8 = "";
+      var path11 = "";
       for (var i2 = 0; i2 < arguments.length; i2++) {
         var segment = arguments[i2];
         if (!isString(segment)) {
           throw new TypeError("Arguments to path.join must be strings");
         }
         if (segment) {
-          if (!path8) {
-            path8 += segment;
+          if (!path11) {
+            path11 += segment;
           } else {
-            path8 += "/" + segment;
+            path11 += "/" + segment;
           }
         }
       }
-      return posix.normalize(path8);
+      return posix.normalize(path11);
     };
     posix.relative = function(from, to) {
       from = posix.resolve(from).substr(1);
@@ -3520,11 +3520,11 @@ var require_path_posix = __commonJS({
       outputParts = outputParts.concat(toParts.slice(samePartsLength));
       return outputParts.join("/");
     };
-    posix._makeLong = function(path8) {
-      return path8;
+    posix._makeLong = function(path11) {
+      return path11;
     };
-    posix.dirname = function(path8) {
-      var result = posixSplitPath(path8), root = result[0], dir = result[1];
+    posix.dirname = function(path11) {
+      var result = posixSplitPath(path11), root = result[0], dir = result[1];
       if (!root && !dir) {
         return ".";
       }
@@ -3533,15 +3533,15 @@ var require_path_posix = __commonJS({
       }
       return root + dir;
     };
-    posix.basename = function(path8, ext2) {
-      var f3 = posixSplitPath(path8)[2];
+    posix.basename = function(path11, ext2) {
+      var f3 = posixSplitPath(path11)[2];
       if (ext2 && f3.substr(-1 * ext2.length) === ext2) {
         f3 = f3.substr(0, f3.length - ext2.length);
       }
       return f3;
     };
-    posix.extname = function(path8) {
-      return posixSplitPath(path8)[3];
+    posix.extname = function(path11) {
+      return posixSplitPath(path11)[3];
     };
     posix.format = function(pathObject) {
       if (!util.isObject(pathObject)) {
@@ -14939,10 +14939,10 @@ var require_nested_property = __commonJS({
         return false;
       }
     }
-    function traverse(object, path8) {
+    function traverse(object, path11) {
       var callback = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : function() {
       };
-      var segments = path8.split(PATH_DELIMITER);
+      var segments = path11.split(PATH_DELIMITER);
       var length = segments.length;
       var _loop = function _loop2(idx2) {
         var currentSegment = segments[idx2];
@@ -15184,11 +15184,11 @@ async function createDirectory(context, dirPath, options = {}) {
   const response = await request(requestOptions, context);
   handleResponseCode(context, response);
 }
-function ensureCollectionPath(path8) {
-  if (!path8.endsWith("/")) {
-    return path8 + "/";
+function ensureCollectionPath(path11) {
+  if (!path11.endsWith("/")) {
+    return path11 + "/";
   }
-  return path8;
+  return path11;
 }
 async function createDirectoryRecursively(context, dirPath, options = {}) {
   const paths = getAllDirectories(normalisePath(dirPath));
@@ -15563,7 +15563,7 @@ var init_xml = __esm({
 });
 
 // ../../node_modules/.pnpm/webdav@5.8.0/node_modules/webdav/dist/node/operations/lock.js
-async function lock(context, path8, options = {}) {
+async function lock(context, path11, options = {}) {
   const { refreshToken, timeout = DEFAULT_TIMEOUT } = options;
   const headers = {
     Accept: "text/plain,application/xml",
@@ -15573,7 +15573,7 @@ async function lock(context, path8, options = {}) {
     headers.If = refreshToken;
   }
   const requestOptions = prepareRequestOptions({
-    url: joinURL(context.remoteURL, encodePath(path8)),
+    url: joinURL(context.remoteURL, encodePath(path11)),
     method: "LOCK",
     headers,
     data: generateLockXML(context.contactHref)
@@ -15593,9 +15593,9 @@ async function lock(context, path8, options = {}) {
     serverTimeout
   };
 }
-async function unlock(context, path8, token, options = {}) {
+async function unlock(context, path11, token, options = {}) {
   const requestOptions = prepareRequestOptions({
-    url: joinURL(context.remoteURL, encodePath(path8)),
+    url: joinURL(context.remoteURL, encodePath(path11)),
     method: "UNLOCK",
     headers: {
       "Lock-Token": token
@@ -15645,9 +15645,9 @@ var init_quota = __esm({
 
 // ../../node_modules/.pnpm/webdav@5.8.0/node_modules/webdav/dist/node/operations/getQuota.js
 async function getQuota(context, options = {}) {
-  const path8 = options.path || "/";
+  const path11 = options.path || "/";
   const requestOptions = prepareRequestOptions({
-    url: joinURL(context.remoteURL, path8),
+    url: joinURL(context.remoteURL, path11),
     method: "PROPFIND",
     headers: {
       Accept: "text/plain,application/xml",
@@ -15987,29 +15987,29 @@ function createClient(remoteURL, options = {}) {
   setupAuth(context, username, password, token, ha1);
   return {
     copyFile: (filename, destination, options2) => copyFile(context, filename, destination, options2),
-    createDirectory: (path8, options2) => createDirectory(context, path8, options2),
+    createDirectory: (path11, options2) => createDirectory(context, path11, options2),
     createReadStream: (filename, options2) => createReadStream2(context, filename, options2),
     createWriteStream: (filename, options2, callback) => createWriteStream(context, filename, options2, callback),
-    customRequest: (path8, requestOptions) => customRequest(context, path8, requestOptions),
+    customRequest: (path11, requestOptions) => customRequest(context, path11, requestOptions),
     deleteFile: (filename, options2) => deleteFile(context, filename, options2),
-    exists: (path8, options2) => exists(context, path8, options2),
-    getDirectoryContents: (path8, options2) => getDirectoryContents(context, path8, options2),
+    exists: (path11, options2) => exists(context, path11, options2),
+    getDirectoryContents: (path11, options2) => getDirectoryContents(context, path11, options2),
     getFileContents: (filename, options2) => getFileContents(context, filename, options2),
     getFileDownloadLink: (filename) => getFileDownloadLink(context, filename),
     getFileUploadLink: (filename) => getFileUploadLink(context, filename),
     getHeaders: () => Object.assign({}, context.headers),
     getQuota: (options2) => getQuota(context, options2),
-    lock: (path8, options2) => lock(context, path8, options2),
+    lock: (path11, options2) => lock(context, path11, options2),
     moveFile: (filename, destinationFilename, options2) => moveFile(context, filename, destinationFilename, options2),
     putFileContents: (filename, data, options2) => putFileContents(context, filename, data, options2),
     partialUpdateFileContents: (filePath, start, end, data, options2) => partialUpdateFileContents(context, filePath, start, end, data, options2),
-    getDAVCompliance: (path8) => getDAVCompliance(context, path8),
-    search: (path8, options2) => getSearch2(context, path8, options2),
+    getDAVCompliance: (path11) => getDAVCompliance(context, path11),
+    search: (path11, options2) => getSearch2(context, path11, options2),
     setHeaders: (headers2) => {
       context.headers = Object.assign({}, headers2);
     },
-    stat: (path8, options2) => getStat(context, path8, options2),
-    unlock: (path8, token2, options2) => unlock(context, path8, token2, options2)
+    stat: (path11, options2) => getStat(context, path11, options2),
+    unlock: (path11, token2, options2) => unlock(context, path11, token2, options2)
   };
 }
 var DEFAULT_CONTACT_HREF;
@@ -16570,6 +16570,149 @@ var init_sync_v2 = __esm({
   }
 });
 
+// ../core/dist/export.js
+function validateExport() {
+  const ccmanDir2 = getCcmanDir();
+  const codexPath = path8.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const claudePath = path8.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const missingFiles = [];
+  if (!fileExists(codexPath)) {
+    missingFiles.push(CODEX_CONFIG_FILE);
+  }
+  if (!fileExists(claudePath)) {
+    missingFiles.push(CLAUDE_CONFIG_FILE);
+  }
+  if (missingFiles.length > 0) {
+    return {
+      valid: false,
+      message: `\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${missingFiles.join(", ")}`,
+      missingFiles
+    };
+  }
+  return { valid: true };
+}
+function validateImportDir(sourceDir) {
+  if (!fileExists(sourceDir)) {
+    return {
+      valid: false,
+      message: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${sourceDir}`,
+      foundFiles: []
+    };
+  }
+  const stats = fs8.statSync(sourceDir);
+  if (!stats.isDirectory()) {
+    return {
+      valid: false,
+      message: `\u4E0D\u662F\u6709\u6548\u7684\u76EE\u5F55: ${sourceDir}`,
+      foundFiles: []
+    };
+  }
+  const codexPath = path8.join(sourceDir, CODEX_CONFIG_FILE);
+  const claudePath = path8.join(sourceDir, CLAUDE_CONFIG_FILE);
+  const foundFiles = [];
+  if (fileExists(codexPath)) {
+    foundFiles.push(CODEX_CONFIG_FILE);
+  }
+  if (fileExists(claudePath)) {
+    foundFiles.push(CLAUDE_CONFIG_FILE);
+  }
+  if (foundFiles.length === 0) {
+    return {
+      valid: false,
+      message: `\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6 (${CODEX_CONFIG_FILE} \u6216 ${CLAUDE_CONFIG_FILE})`,
+      foundFiles: []
+    };
+  }
+  return {
+    valid: true,
+    foundFiles
+  };
+}
+function exportConfig(targetDir) {
+  const validation = validateExport();
+  if (!validation.valid) {
+    throw new Error(validation.message);
+  }
+  ensureDir(targetDir);
+  const ccmanDir2 = getCcmanDir();
+  const exportedFiles = [];
+  const codexSrc = path8.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const codexDst = path8.join(targetDir, CODEX_CONFIG_FILE);
+  if (fileExists(codexSrc)) {
+    fs8.copyFileSync(codexSrc, codexDst);
+    exportedFiles.push(CODEX_CONFIG_FILE);
+  }
+  const claudeSrc = path8.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const claudeDst = path8.join(targetDir, CLAUDE_CONFIG_FILE);
+  if (fileExists(claudeSrc)) {
+    fs8.copyFileSync(claudeSrc, claudeDst);
+    exportedFiles.push(CLAUDE_CONFIG_FILE);
+  }
+  return {
+    success: true,
+    targetDir,
+    exportedFiles
+  };
+}
+function importConfig(sourceDir) {
+  const validation = validateImportDir(sourceDir);
+  if (!validation.valid) {
+    throw new Error(validation.message);
+  }
+  const ccmanDir2 = getCcmanDir();
+  const backupPaths = [];
+  const importedFiles = [];
+  ensureDir(ccmanDir2);
+  try {
+    if (validation.foundFiles.includes(CODEX_CONFIG_FILE)) {
+      const codexDst = path8.join(ccmanDir2, CODEX_CONFIG_FILE);
+      if (fileExists(codexDst)) {
+        const backupPath = backupConfig(codexDst);
+        backupPaths.push(backupPath);
+      }
+      const codexSrc = path8.join(sourceDir, CODEX_CONFIG_FILE);
+      fs8.copyFileSync(codexSrc, codexDst);
+      importedFiles.push(CODEX_CONFIG_FILE);
+    }
+    if (validation.foundFiles.includes(CLAUDE_CONFIG_FILE)) {
+      const claudeDst = path8.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+      if (fileExists(claudeDst)) {
+        const backupPath = backupConfig(claudeDst);
+        backupPaths.push(backupPath);
+      }
+      const claudeSrc = path8.join(sourceDir, CLAUDE_CONFIG_FILE);
+      fs8.copyFileSync(claudeSrc, claudeDst);
+      importedFiles.push(CLAUDE_CONFIG_FILE);
+    }
+    return {
+      success: true,
+      backupPaths,
+      importedFiles
+    };
+  } catch (error) {
+    for (const backupPath of backupPaths) {
+      const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
+      if (fileExists(backupPath)) {
+        fs8.copyFileSync(backupPath, originalPath);
+      }
+    }
+    throw new Error(`\u5BFC\u5165\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
+  }
+}
+var fs8, path8, CODEX_CONFIG_FILE, CLAUDE_CONFIG_FILE;
+var init_export = __esm({
+  "../core/dist/export.js"() {
+    "use strict";
+    fs8 = __toESM(require("fs"), 1);
+    path8 = __toESM(require("path"), 1);
+    init_paths();
+    init_file();
+    init_merge2();
+    CODEX_CONFIG_FILE = "codex.json";
+    CLAUDE_CONFIG_FILE = "claude.json";
+  }
+});
+
 // ../core/dist/index.js
 var VERSION;
 var init_dist4 = __esm({
@@ -16587,6 +16730,7 @@ var init_dist4 = __esm({
     init_sync_v2();
     init_crypto2();
     init_merge_advanced();
+    init_export();
     VERSION = package_default.version;
   }
 });
@@ -17038,8 +17182,8 @@ function downloadCommand(program2) {
       console.log();
       if (backupPaths.length > 0) {
         console.log(import_chalk6.default.gray("\u672C\u5730\u5907\u4EFD:"));
-        backupPaths.forEach((path8) => {
-          console.log(import_chalk6.default.gray(`  ${path8}`));
+        backupPaths.forEach((path11) => {
+          console.log(import_chalk6.default.gray(`  ${path11}`));
         });
         console.log();
       }
@@ -17103,8 +17247,8 @@ function mergeCommand(program2) {
       console.log();
       if (result.backupPaths.length > 0) {
         console.log(import_chalk7.default.gray("\u5907\u4EFD:"));
-        result.backupPaths.forEach((path8) => {
-          console.log(import_chalk7.default.gray(`  ${path8}`));
+        result.backupPaths.forEach((path11) => {
+          console.log(import_chalk7.default.gray(`  ${path11}`));
         });
         console.log();
       }
@@ -17303,7 +17447,7 @@ var init_sync2 = __esm({
 
 // src/index.ts
 var import_commander2 = require("commander");
-var import_chalk25 = __toESM(require("chalk"));
+var import_chalk27 = __toESM(require("chalk"));
 
 // src/utils/logo.ts
 var import_chalk = __toESM(require("chalk"));
@@ -18743,12 +18887,138 @@ function createClaudeCommands(program2) {
 
 // src/index.ts
 init_sync2();
+
+// src/commands/export.ts
+var import_chalk25 = __toESM(require("chalk"));
+var import_path18 = __toESM(require("path"));
+init_dist4();
+function exportCommand(program2) {
+  program2.command("export <\u76EE\u6807\u76EE\u5F55>").description("\u5BFC\u51FA\u914D\u7F6E\u5230\u672C\u5730\u76EE\u5F55\uFF08\u5305\u542B API Key\uFF09").action(async (targetDir) => {
+    try {
+      console.log(import_chalk25.default.bold("\n\u{1F4E6} \u5BFC\u51FA\u914D\u7F6E\n"));
+      const validation = validateExport();
+      if (!validation.valid) {
+        console.log(import_chalk25.default.red(`\u274C ${validation.message}
+`));
+        process.exit(1);
+      }
+      const resolvedPath = targetDir.startsWith("~") ? import_path18.default.join(process.env.HOME || "", targetDir.slice(1)) : import_path18.default.resolve(targetDir);
+      console.log("\u5BFC\u51FA\u6587\u4EF6:");
+      console.log(`  ${import_chalk25.default.cyan("codex.json")}  - Codex \u914D\u7F6E`);
+      console.log(`  ${import_chalk25.default.cyan("claude.json")} - Claude \u914D\u7F6E`);
+      console.log();
+      console.log(`\u76EE\u6807\u76EE\u5F55: ${import_chalk25.default.cyan(resolvedPath)}`);
+      console.log();
+      console.log(import_chalk25.default.yellow("\u26A0\uFE0F  \u5BFC\u51FA\u6587\u4EF6\u5305\u542B API Key\uFF0C\u8BF7\u59A5\u5584\u4FDD\u7BA1"));
+      console.log();
+      const result = exportConfig(resolvedPath);
+      console.log(import_chalk25.default.green("\u2705 \u5BFC\u51FA\u6210\u529F"));
+      console.log();
+      console.log("\u5DF2\u5BFC\u51FA\u6587\u4EF6:");
+      for (const file of result.exportedFiles) {
+        console.log(`  ${import_chalk25.default.cyan("\u2713")} ${file}`);
+      }
+      console.log();
+      console.log(import_chalk25.default.blue(`\u{1F4A1} \u5BFC\u5165\u547D\u4EE4: ccman import ${resolvedPath}
+`));
+    } catch (error) {
+      console.error(import_chalk25.default.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/import.ts
+var import_chalk26 = __toESM(require("chalk"));
+var import_inquirer17 = __toESM(require("inquirer"));
+var import_path19 = __toESM(require("path"));
+init_dist4();
+function importCommand(program2) {
+  program2.command("import <\u6E90\u76EE\u5F55>").description("\u4ECE\u672C\u5730\u76EE\u5F55\u5BFC\u5165\u914D\u7F6E\uFF08\u4F1A\u8986\u76D6\u5F53\u524D\u914D\u7F6E\uFF09").action(async (sourceDir) => {
+    try {
+      const resolvedPath = sourceDir.startsWith("~") ? import_path19.default.join(process.env.HOME || "", sourceDir.slice(1)) : import_path19.default.resolve(sourceDir);
+      console.log(import_chalk26.default.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
+      const validation = validateImportDir(resolvedPath);
+      if (!validation.valid) {
+        console.log(import_chalk26.default.red(`\u274C ${validation.message}
+`));
+        process.exit(1);
+      }
+      console.log(import_chalk26.default.yellow("\u26A0\uFE0F  \u8B66\u544A\uFF1A\u5BFC\u5165\u5C06\u8986\u76D6\u5F53\u524D\u914D\u7F6E\n"));
+      console.log(`\u6E90\u76EE\u5F55: ${import_chalk26.default.cyan(resolvedPath)}`);
+      console.log();
+      console.log("\u627E\u5230\u914D\u7F6E\u6587\u4EF6:");
+      for (const file of validation.foundFiles) {
+        console.log(`  ${import_chalk26.default.cyan("\u2713")} ${file}`);
+      }
+      console.log();
+      console.log(import_chalk26.default.gray("\u5F53\u524D\u914D\u7F6E\u5C06\u88AB\u8986\u76D6\uFF08\u81EA\u52A8\u5907\u4EFD\uFF09"));
+      console.log();
+      const { confirmFirst } = await import_inquirer17.default.prompt([
+        {
+          type: "confirm",
+          name: "confirmFirst",
+          message: "\u786E\u8BA4\u5BFC\u5165\uFF1F",
+          default: false
+        }
+      ]);
+      if (!confirmFirst) {
+        console.log(import_chalk26.default.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
+        return;
+      }
+      console.log();
+      console.log(import_chalk26.default.red.bold("\u26A0\uFE0F  \u6700\u540E\u786E\u8BA4\uFF1A\u6B64\u64CD\u4F5C\u5C06\u8986\u76D6\u6240\u6709\u5F53\u524D\u914D\u7F6E\uFF01"));
+      console.log();
+      const { confirmSecond } = await import_inquirer17.default.prompt([
+        {
+          type: "confirm",
+          name: "confirmSecond",
+          message: "\u771F\u7684\u8981\u7EE7\u7EED\u5417\uFF1F",
+          default: false
+        }
+      ]);
+      if (!confirmSecond) {
+        console.log(import_chalk26.default.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
+        return;
+      }
+      console.log();
+      console.log(import_chalk26.default.gray("\u{1F4BE} \u5907\u4EFD\u5F53\u524D\u914D\u7F6E..."));
+      console.log(import_chalk26.default.gray("\u{1F4E5} \u5BFC\u5165\u65B0\u914D\u7F6E..."));
+      const result = importConfig(resolvedPath);
+      console.log();
+      console.log(import_chalk26.default.green("\u2705 \u5BFC\u5165\u6210\u529F"));
+      console.log();
+      if (result.backupPaths.length > 0) {
+        console.log("\u5907\u4EFD\u6587\u4EF6:");
+        for (const backupPath of result.backupPaths) {
+          console.log(`  ${import_chalk26.default.gray(backupPath)}`);
+        }
+        console.log();
+      }
+      console.log("\u5DF2\u5BFC\u5165\u6587\u4EF6:");
+      for (const file of result.importedFiles) {
+        console.log(`  ${import_chalk26.default.cyan("\u2713")} ${file}`);
+      }
+      console.log();
+      console.log(import_chalk26.default.blue("\u{1F4A1} \u8BF7\u4F7F\u7528 'ccman cx use' \u6216 'ccman cc use' \u5207\u6362\u670D\u52A1\u5546\n"));
+    } catch (error) {
+      console.error(import_chalk26.default.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
 init_dist4();
 if (process.env.NODE_ENV === "development") {
-  console.log(import_chalk25.default.gray("\n[\u5F00\u53D1\u6A21\u5F0F] \u914D\u7F6E\u76EE\u5F55:"));
-  console.log(import_chalk25.default.gray(`  ccman: ${getCcmanDir()}`));
-  console.log(import_chalk25.default.gray(`  codex:  ${getCodexDir()}`));
-  console.log(import_chalk25.default.gray(`  claude: ${getClaudeDir()}`));
+  console.log(import_chalk27.default.gray("\n[\u5F00\u53D1\u6A21\u5F0F] \u914D\u7F6E\u76EE\u5F55:"));
+  console.log(import_chalk27.default.gray(`  ccman: ${getCcmanDir()}`));
+  console.log(import_chalk27.default.gray(`  codex:  ${getCodexDir()}`));
+  console.log(import_chalk27.default.gray(`  claude: ${getClaudeDir()}`));
   console.log();
 }
 var program = new import_commander2.Command();
@@ -18776,6 +19046,8 @@ sync.action(async () => {
   printLogo();
   await startSyncMenu();
 });
+exportCommand(program);
+importCommand(program);
 (async () => {
   if (!process.argv.slice(2).length) {
     printLogo();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccman",
-  "version": "3.0.14",
+  "version": "3.0.16",
   "description": "Manage Codex and Claude Code API service provider configurations",
   "main": "./dist/index.js",
   "bin": {