ccman 3.3.12 → 3.3.14-beta.0

package/dist/index.js

@@ -15,9 +15,9 @@ var init_package = __esm({
   "../core/package.json"() {
     package_default = {
       name: "@ccman/core",
-      version: "3.3.12",
+      version: "3.3.14-beta.0",
       type: "module",
-      description: "Core business logic for ccman - Manage Codex, Claude Code, Gemini CLI, and MCP configurations",
+      description: "Core business logic for ccman - Manage Codex, Claude Code, Gemini CLI, OpenCode, OpenClaw, and MCP configurations",
       main: "./dist/index.js",
       types: "./dist/index.d.ts",
       files: [
@@ -36,6 +36,8 @@ var init_package = __esm({
         "claude-code",
         "gemini",
         "gemini-cli",
+        "opencode",
+        "openclaw",
         "mcp",
         "model-context-protocol",
         "ai",
@@ -80,12 +82,14 @@ var init_dist = __esm({
       CLAUDE: "claude",
       MCP: "mcp",
       GEMINI: "gemini",
-      OPENCODE: "opencode"
+      OPENCODE: "opencode",
+      OPENCLAW: "openclaw"
     };
     MAIN_TOOL_TYPES = {
       CODEX: TOOL_TYPES.CODEX,
       CLAUDE: TOOL_TYPES.CLAUDE,
-      GEMINI: TOOL_TYPES.GEMINI
+      GEMINI: TOOL_TYPES.GEMINI,
+      OPENCLAW: TOOL_TYPES.OPENCLAW
     };
     TOOL_CONFIG = {
       [TOOL_TYPES.CODEX]: {
@@ -127,6 +131,14 @@ var init_dist = __esm({
         bgColorClass: "bg-amber-50",
         hoverBgColorClass: "hover:bg-amber-100",
         description: "OpenCode \u914D\u7F6E"
+      },
+      [TOOL_TYPES.OPENCLAW]: {
+        displayName: "OpenClaw",
+        color: "teal",
+        textColorClass: "text-teal-600",
+        bgColorClass: "bg-teal-50",
+        hoverBgColorClass: "hover:bg-teal-100",
+        description: "OpenClaw \u914D\u7F6E"
       }
     };
   }
@@ -159,6 +171,9 @@ function getGeminiDir() {
 function getOpenCodeDir() {
   return opencodeDir;
 }
+function getOpenClawDir() {
+  return openclawDir;
+}
 function getConfigPath() {
   return path.join(ccmanDir, "config.json");
 }
@@ -183,7 +198,13 @@ function getGeminiEnvPath() {
 function getOpenCodeConfigPath() {
   return path.join(opencodeDir, "opencode.json");
 }
-var isDev, isTest, rootDir, ccmanDir, codexDir, claudeDir, geminiDir, opencodeDir;
+function getOpenClawConfigPath() {
+  return path.join(openclawDir, "openclaw.json");
+}
+function getOpenClawModelsPath() {
+  return path.join(openclawDir, "agents", "main", "agent", "models.json");
+}
+var isDev, isTest, rootDir, ccmanDir, codexDir, claudeDir, geminiDir, opencodeDir, openclawDir;
 var init_paths = __esm({
   "../core/dist/paths.js"() {
     "use strict";
@@ -201,6 +222,7 @@ var init_paths = __esm({
     claudeDir = path.join(rootDir, ".claude");
     geminiDir = path.join(rootDir, ".gemini");
     opencodeDir = path.join(rootDir, ".config", "opencode");
+    openclawDir = path.join(rootDir, ".openclaw");
   }
 });
 
@@ -785,6 +807,21 @@ var init_opencode = __esm({
   }
 });
 
+// ../core/dist/presets/openclaw.js
+var OPENCLAW_PRESETS;
+var init_openclaw = __esm({
+  "../core/dist/presets/openclaw.js"() {
+    "use strict";
+    OPENCLAW_PRESETS = [
+      {
+        name: "GMN",
+        baseUrl: "https://gmn.chuangzuoli.com/v1",
+        description: "GMN \u670D\u52A1 (OpenClaw \u517C\u5BB9)"
+      }
+    ];
+  }
+});
+
 // ../core/dist/writers/gemini.js
 import * as fs5 from "fs";
 import * as path6 from "path";
@@ -1134,6 +1171,216 @@ var init_opencode2 = __esm({
   }
 });
 
+// ../core/dist/writers/openclaw.js
+import * as fs7 from "fs";
+import * as path8 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+function resolveTemplatePath5(relativePath) {
+  const candidates = [
+    // @ccman/core runtime (dist/writers -> templates)
+    path8.resolve(__dirname5, "../../templates", relativePath),
+    // Bundled CLI runtime (dist -> dist/templates)
+    path8.resolve(__dirname5, "templates", relativePath),
+    // Fallback (some bundlers/layouts)
+    path8.resolve(__dirname5, "../templates", relativePath)
+  ];
+  for (const candidate of candidates) {
+    if (fs7.existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function loadTemplate(relativePath, fallback) {
+  try {
+    const templatePath = resolveTemplatePath5(relativePath);
+    if (templatePath) {
+      const content = fs7.readFileSync(templatePath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+    }
+  } catch {
+  }
+  return fallback;
+}
+function parseModelMeta(raw) {
+  const defaults = {
+    providerKey: DEFAULT_PROVIDER_KEY,
+    primaryModelId: DEFAULT_PRIMARY_MODEL_ID,
+    secondaryModelId: DEFAULT_SECONDARY_MODEL_ID,
+    includeSecondaryModel: true
+  };
+  if (!raw || !raw.trim()) {
+    return defaults;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return defaults;
+    }
+    const obj = parsed;
+    return {
+      providerKey: (obj.providerKey || defaults.providerKey).trim(),
+      primaryModelId: (obj.primaryModelId || defaults.primaryModelId).trim(),
+      secondaryModelId: (obj.secondaryModelId || defaults.secondaryModelId).trim(),
+      includeSecondaryModel: obj.includeSecondaryModel === void 0 ? defaults.includeSecondaryModel : Boolean(obj.includeSecondaryModel)
+    };
+  } catch {
+    return {
+      ...defaults,
+      primaryModelId: raw.trim()
+    };
+  }
+}
+function createModel(id) {
+  return {
+    id,
+    name: id,
+    api: OPENAI_RESPONSES_API,
+    reasoning: false,
+    input: ["text"],
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0
+    },
+    contextWindow: 2e5,
+    maxTokens: 8192
+  };
+}
+function writeOpenClawConfig(provider) {
+  const configPath = getOpenClawConfigPath();
+  const modelsPath = getOpenClawModelsPath();
+  const homeDir = path8.dirname(getOpenClawDir());
+  ensureDir(getOpenClawDir());
+  ensureDir(path8.dirname(modelsPath));
+  const meta = parseModelMeta(provider.model);
+  const providerKey = meta.providerKey || DEFAULT_PROVIDER_KEY;
+  const primaryModelId = meta.primaryModelId || DEFAULT_PRIMARY_MODEL_ID;
+  const secondaryModelId = meta.secondaryModelId || DEFAULT_SECONDARY_MODEL_ID;
+  const includeSecondaryModel = meta.includeSecondaryModel && secondaryModelId && secondaryModelId !== primaryModelId;
+  const rawConfigTemplate = loadTemplate("openclaw/openclaw.base.template.json", OPENCLAW_CONFIG_TEMPLATE);
+  const rawModelsTemplate = loadTemplate("openclaw/models.base.template.json", OPENCLAW_MODELS_TEMPLATE);
+  const variables = {
+    homeDir,
+    providerKey,
+    baseUrl: provider.baseUrl || "",
+    apiKey: provider.apiKey || "",
+    primaryModelId,
+    secondaryModelId
+  };
+  const configTemplate = replaceVariables(rawConfigTemplate, variables);
+  const modelsTemplate = replaceVariables(rawModelsTemplate, variables);
+  const nextModelsConfig = {
+    ...modelsTemplate,
+    providers: {
+      [providerKey]: {
+        ...(modelsTemplate.providers || {})[providerKey] || {},
+        baseUrl: provider.baseUrl,
+        apiKey: provider.apiKey,
+        api: OPENAI_RESPONSES_API,
+        authHeader: true,
+        headers: {
+          "User-Agent": "curl/8.0",
+          "OpenAI-Beta": "responses=v1"
+        },
+        models: includeSecondaryModel ? [createModel(primaryModelId), createModel(secondaryModelId)] : [createModel(primaryModelId)]
+      }
+    }
+  };
+  const defaults = configTemplate.agents?.defaults || {};
+  const nextOpenClawConfig = {
+    ...configTemplate,
+    models: {
+      ...configTemplate.models || {},
+      mode: configTemplate.models?.mode || "merge",
+      providers: configTemplate.models?.providers || {}
+    },
+    agents: {
+      ...configTemplate.agents || {},
+      defaults: {
+        ...defaults,
+        workspace: homeDir,
+        model: {
+          ...defaults.model || {},
+          primary: `${providerKey}/${primaryModelId}`
+        },
+        thinkingDefault: defaults.thinkingDefault || "xhigh"
+      }
+    }
+  };
+  writeJSON(configPath, nextOpenClawConfig);
+  writeJSON(modelsPath, nextModelsConfig);
+}
+var DEFAULT_PROVIDER_KEY, DEFAULT_PRIMARY_MODEL_ID, DEFAULT_SECONDARY_MODEL_ID, OPENAI_RESPONSES_API, __filename5, __dirname5, OPENCLAW_CONFIG_TEMPLATE, OPENCLAW_MODELS_TEMPLATE;
+var init_openclaw2 = __esm({
+  "../core/dist/writers/openclaw.js"() {
+    "use strict";
+    init_paths();
+    init_file();
+    init_template();
+    DEFAULT_PROVIDER_KEY = "sub2api";
+    DEFAULT_PRIMARY_MODEL_ID = "gpt-5.3-codex";
+    DEFAULT_SECONDARY_MODEL_ID = "gpt-5.2-codex";
+    OPENAI_RESPONSES_API = "openai-responses";
+    __filename5 = fileURLToPath5(import.meta.url);
+    __dirname5 = path8.dirname(__filename5);
+    OPENCLAW_CONFIG_TEMPLATE = {
+      models: {
+        mode: "merge",
+        providers: {}
+      },
+      agents: {
+        defaults: {
+          workspace: "",
+          model: {
+            primary: `${DEFAULT_PROVIDER_KEY}/${DEFAULT_PRIMARY_MODEL_ID}`
+          },
+          thinkingDefault: "xhigh"
+        }
+      }
+    };
+    OPENCLAW_MODELS_TEMPLATE = {
+      providers: {
+        [DEFAULT_PROVIDER_KEY]: {
+          baseUrl: "https://gmn.chuangzuoli.com/v1",
+          apiKey: "",
+          api: OPENAI_RESPONSES_API,
+          authHeader: true,
+          headers: {
+            "User-Agent": "curl/8.0",
+            "OpenAI-Beta": "responses=v1"
+          },
+          models: [
+            {
+              id: DEFAULT_PRIMARY_MODEL_ID,
+              name: DEFAULT_PRIMARY_MODEL_ID,
+              api: OPENAI_RESPONSES_API,
+              reasoning: false,
+              input: ["text"],
+              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+              contextWindow: 2e5,
+              maxTokens: 8192
+            },
+            {
+              id: DEFAULT_SECONDARY_MODEL_ID,
+              name: DEFAULT_SECONDARY_MODEL_ID,
+              api: OPENAI_RESPONSES_API,
+              reasoning: false,
+              input: ["text"],
+              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+              contextWindow: 2e5,
+              maxTokens: 8192
+            }
+          ]
+        }
+      }
+    };
+  }
+});
+
 // ../core/dist/tool-manager.types.js
 var ProviderNotFoundError, ProviderNameConflictError, PresetNameConflictError;
 var init_tool_manager_types = __esm({
@@ -1161,7 +1408,7 @@ var init_tool_manager_types = __esm({
 });
 
 // ../core/dist/tool-manager.js
-import * as path8 from "path";
+import * as path9 from "path";
 function createToolManager(tool) {
   const toolConfig = TOOL_CONFIGS[tool];
   const configPath = toolConfig.configPath;
@@ -1475,6 +1722,9 @@ function createGeminiManager() {
 function createOpenCodeManager() {
   return createToolManager("opencode");
 }
+function createOpenClawManager() {
+  return createToolManager("openclaw");
+}
 var TOOL_CONFIGS;
 var init_tool_manager = __esm({
   "../core/dist/tool-manager.js"() {
@@ -1489,22 +1739,24 @@ var init_tool_manager = __esm({
     init_mcp2();
     init_gemini();
     init_opencode();
+    init_openclaw();
     init_gemini2();
     init_opencode2();
+    init_openclaw2();
     init_tool_manager_types();
     TOOL_CONFIGS = {
       codex: {
-        configPath: path8.join(getCcmanDir(), "codex.json"),
+        configPath: path9.join(getCcmanDir(), "codex.json"),
         builtinPresets: CODEX_PRESETS,
         writer: writeCodexConfig
       },
       claude: {
-        configPath: path8.join(getCcmanDir(), "claude.json"),
+        configPath: path9.join(getCcmanDir(), "claude.json"),
         builtinPresets: CC_PRESETS,
         writer: writeClaudeConfig
       },
       mcp: {
-        configPath: path8.join(getCcmanDir(), "mcp.json"),
+        configPath: path9.join(getCcmanDir(), "mcp.json"),
         builtinPresets: MCP_PRESETS,
         writer: writeMCPConfig,
         autoSync: true,
@@ -1534,14 +1786,19 @@ var init_tool_manager = __esm({
         }
       },
       gemini: {
-        configPath: path8.join(getCcmanDir(), "gemini.json"),
+        configPath: path9.join(getCcmanDir(), "gemini.json"),
         builtinPresets: GEMINI_PRESETS,
         writer: writeGeminiConfig
       },
       opencode: {
-        configPath: path8.join(getCcmanDir(), "opencode.json"),
+        configPath: path9.join(getCcmanDir(), "opencode.json"),
         builtinPresets: OPENCODE_PRESETS,
         writer: writeOpenCodeConfig
+      },
+      openclaw: {
+        configPath: path9.join(getCcmanDir(), "openclaw.json"),
+        builtinPresets: OPENCLAW_PRESETS,
+        writer: writeOpenClawConfig
       }
     };
   }
@@ -1556,20 +1813,20 @@ var init_migrate = __esm({
 });
 
 // ../core/dist/config.js
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 function ensureConfigDir() {
   const dir = getCcmanDir();
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true, mode: 448 });
   }
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!fs7.existsSync(configPath)) {
+  if (!fs8.existsSync(configPath)) {
     return {};
   }
   try {
-    const content = fs7.readFileSync(configPath, "utf-8");
+    const content = fs8.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     throw new Error(`Failed to load config: ${error.message}`);
@@ -1580,10 +1837,10 @@ function saveConfig(config) {
   const configPath = getConfigPath();
   try {
     const tempPath = `${configPath}.tmp`;
-    fs7.writeFileSync(tempPath, JSON.stringify(config, null, 2), {
+    fs8.writeFileSync(tempPath, JSON.stringify(config, null, 2), {
       mode: 384
     });
-    fs7.renameSync(tempPath, configPath);
+    fs8.renameSync(tempPath, configPath);
   } catch (error) {
     throw new Error(`Failed to save config: ${error.message}`);
   }
@@ -1915,24 +2172,24 @@ var init_merge_advanced = __esm({
 });
 
 // ../core/dist/sync/merge.js
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 function backupConfig(configPath, keepCount = 3) {
-  if (!fs8.existsSync(configPath)) {
+  if (!fs9.existsSync(configPath)) {
     throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${configPath}`);
   }
   const timestamp = Date.now();
   const backupPath = `${configPath}.backup.${timestamp}`;
-  fs8.copyFileSync(configPath, backupPath);
+  fs9.copyFileSync(configPath, backupPath);
   cleanupOldBackups(configPath, keepCount);
   return backupPath;
 }
 function cleanupOldBackups(configPath, keepCount) {
-  const dir = path9.dirname(configPath);
-  const basename = path9.basename(configPath);
+  const dir = path10.dirname(configPath);
+  const basename = path10.basename(configPath);
   const backupPrefix = `${basename}.backup.`;
   try {
-    const files = fs8.readdirSync(dir);
+    const files = fs9.readdirSync(dir);
     const backups = files.filter((f) => f.startsWith(backupPrefix)).map((f) => {
       const timestampStr = f.substring(backupPrefix.length);
       const timestamp = parseInt(timestampStr, 10);
@@ -1941,14 +2198,14 @@ function cleanupOldBackups(configPath, keepCount) {
       }
       return {
         name: f,
-        path: path9.join(dir, f),
+        path: path10.join(dir, f),
         timestamp
       };
     }).filter((backup) => backup !== null).sort((a, b) => b.timestamp - a.timestamp);
     const toDelete = backups.slice(keepCount);
     for (const backup of toDelete) {
       try {
-        fs8.unlinkSync(backup.path);
+        fs9.unlinkSync(backup.path);
       } catch (error) {
         console.warn(`\u65E0\u6CD5\u5220\u9664\u65E7\u5907\u4EFD\u6587\u4EF6 ${backup.name}: ${error.message}`);
       }
@@ -1964,15 +2221,31 @@ var init_merge = __esm({
 });
 
 // ../core/dist/sync/sync-v2.js
-import fs9 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path11 from "path";
+function createEmptyToolConfig() {
+  return {
+    providers: [],
+    presets: []
+  };
+}
+function readLocalConfigOrEmpty(configPath) {
+  if (!fileExists(configPath)) {
+    return createEmptyToolConfig();
+  }
+  return readJSON(configPath);
+}
 async function uploadToCloud(config, password) {
   const ccmanDir2 = getCcmanDir();
   const toolKeys = Object.keys(TOOL_SYNC_CONFIG);
+  let uploadedCount = 0;
   for (const tool of toolKeys) {
     const { remotePath, configFilename } = TOOL_SYNC_CONFIG[tool];
-    const configPath = path10.join(ccmanDir2, configFilename);
-    const localConfig = readJSON(configPath);
+    const configPath = path11.join(ccmanDir2, configFilename);
+    if (!fileExists(configPath)) {
+      continue;
+    }
+    const localConfig = readLocalConfigOrEmpty(configPath);
     const encryptedProviders = encryptProviders(localConfig.providers, password);
     const encryptedConfig = {
       ...localConfig,
@@ -1982,6 +2255,10 @@ async function uploadToCloud(config, password) {
     };
     const jsonContent = JSON.stringify(encryptedConfig, null, 2);
     await uploadToWebDAV(config, remotePath, jsonContent);
+    uploadedCount += 1;
+  }
+  if (uploadedCount === 0) {
+    throw new Error("\u672C\u5730\u672A\u627E\u5230\u53EF\u4E0A\u4F20\u7684\u914D\u7F6E\u6587\u4EF6");
   }
   updateLastSyncTime();
   console.log("\u2705 \u914D\u7F6E\u5DF2\u4E0A\u4F20\u5230\u4E91\u7AEF");
@@ -2017,8 +2294,8 @@ async function downloadFromCloud(config, password) {
   try {
     for (const tool of toolKeys) {
       const { configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path10.join(ccmanDir2, configFilename);
-      if (fs9.existsSync(configPath)) {
+      const configPath = path11.join(ccmanDir2, configFilename);
+      if (fs10.existsSync(configPath)) {
         backupPaths.push(backupConfig(configPath));
       }
     }
@@ -2030,7 +2307,7 @@ async function downloadFromCloud(config, password) {
       if (!remoteConfig || !decryptedProviders)
         continue;
       const { configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path10.join(ccmanDir2, configFilename);
+      const configPath = path11.join(ccmanDir2, configFilename);
       const newConfig = {
         ...remoteConfig,
         // 使用云端配置的所有字段
@@ -2046,8 +2323,8 @@ async function downloadFromCloud(config, password) {
   } catch (error) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
-      if (fs9.existsSync(backupPath)) {
-        fs9.copyFileSync(backupPath, originalPath);
+      if (fs10.existsSync(backupPath)) {
+        fs10.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u8986\u76D6\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
@@ -2072,8 +2349,8 @@ async function mergeSync(config, password) {
   for (let i = 0; i < toolKeys.length; i++) {
     const tool = toolKeys[i];
     const { remotePath, configFilename } = TOOL_SYNC_CONFIG[tool];
-    const configPath = path10.join(ccmanDir2, configFilename);
-    const localConfig = readJSON(configPath);
+    const configPath = path11.join(ccmanDir2, configFilename);
+    const localConfig = readLocalConfigOrEmpty(configPath);
     let remoteProviders = [];
     if (existsChecks[i]) {
       try {
@@ -2104,8 +2381,8 @@ async function mergeSync(config, password) {
   try {
     for (const tool of toolKeys) {
       const { configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path10.join(ccmanDir2, configFilename);
-      if (fs9.existsSync(configPath)) {
+      const configPath = path11.join(ccmanDir2, configFilename);
+      if (fs10.existsSync(configPath)) {
         backupPaths.push(backupConfig(configPath));
       }
     }
@@ -2116,7 +2393,7 @@ async function mergeSync(config, password) {
     for (let i = 0; i < mergeDataList.length; i++) {
       const { tool, localConfig, mergeResult } = mergeDataList[i];
       const { remotePath, configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path10.join(ccmanDir2, configFilename);
+      const configPath = path11.join(ccmanDir2, configFilename);
       let remoteConfig = null;
       if (existsChecks[i]) {
         const jsonContent2 = await downloadFromWebDAV(config, remotePath);
@@ -2131,6 +2408,10 @@ async function mergeSync(config, password) {
         presets: mergedPresets
         // 替换为合并后的 presets
       };
+      const shouldPersist = fileExists(configPath) || existsChecks[i] || mergeResult.merged.length > 0 || mergedPresets && mergedPresets.length > 0;
+      if (!shouldPersist) {
+        continue;
+      }
       writeJSON(configPath, mergedConfig);
       applyCurrentProvider(tool, mergedConfig);
       const encryptedProviders = encryptProviders(mergeResult.merged, password);
@@ -2152,8 +2433,8 @@ async function mergeSync(config, password) {
   } catch (error) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
-      if (fs9.existsSync(backupPath)) {
-        fs9.copyFileSync(backupPath, originalPath);
+      if (fs10.existsSync(backupPath)) {
+        fs10.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u5408\u5E76\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
@@ -2184,6 +2465,7 @@ var init_sync_v2 = __esm({
     init_codex();
     init_claude();
     init_gemini2();
+    init_openclaw2();
     init_constants();
     TOOL_SYNC_CONFIG = {
       [MAIN_TOOL_TYPES.CODEX]: {
@@ -2200,33 +2482,35 @@ var init_sync_v2 = __esm({
         remotePath: ".ccman/gemini.json",
         configFilename: "gemini.json",
         writerFunc: writeGeminiConfig
+      },
+      [MAIN_TOOL_TYPES.OPENCLAW]: {
+        remotePath: ".ccman/openclaw.json",
+        configFilename: "openclaw.json",
+        writerFunc: writeOpenClawConfig
       }
     };
   }
 });
 
 // ../core/dist/export.js
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 function validateExport() {
   const ccmanDir2 = getCcmanDir();
-  const codexPath = path11.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const claudePath = path11.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) {
+  const foundFiles = SUPPORTED_CONFIG_FILES.filter((filename) => fileExists(path12.join(ccmanDir2, filename)));
+  if (foundFiles.length === 0) {
     return {
       valid: false,
-      message: `\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${missingFiles.join(", ")}`,
-      missingFiles
+      message: `\u672A\u627E\u5230\u53EF\u5BFC\u51FA\u7684\u914D\u7F6E\u6587\u4EF6 (${SUPPORTED_CONFIG_FILES.join(" / ")})`,
+      missingFiles: [...SUPPORTED_CONFIG_FILES],
+      foundFiles: []
     };
   }
-  return { valid: true };
+  return {
+    valid: true,
+    foundFiles,
+    missingFiles: SUPPORTED_CONFIG_FILES.filter((file) => !foundFiles.includes(file))
+  };
 }
 function validateImportDir(sourceDir) {
   if (!fileExists(sourceDir)) {
@@ -2236,7 +2520,7 @@ function validateImportDir(sourceDir) {
       foundFiles: []
     };
   }
-  const stats = fs10.statSync(sourceDir);
+  const stats = fs11.statSync(sourceDir);
   if (!stats.isDirectory()) {
     return {
       valid: false,
@@ -2244,19 +2528,11 @@ function validateImportDir(sourceDir) {
       foundFiles: []
     };
   }
-  const codexPath = path11.join(sourceDir, CODEX_CONFIG_FILE);
-  const claudePath = path11.join(sourceDir, CLAUDE_CONFIG_FILE);
-  const foundFiles = [];
-  if (fileExists(codexPath)) {
-    foundFiles.push(CODEX_CONFIG_FILE);
-  }
-  if (fileExists(claudePath)) {
-    foundFiles.push(CLAUDE_CONFIG_FILE);
-  }
+  const foundFiles = SUPPORTED_CONFIG_FILES.filter((filename) => fileExists(path12.join(sourceDir, filename)));
   if (foundFiles.length === 0) {
     return {
       valid: false,
-      message: `\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6 (${CODEX_CONFIG_FILE} \u6216 ${CLAUDE_CONFIG_FILE})`,
+      message: `\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6 (${SUPPORTED_CONFIG_FILES.join(" / ")})`,
       foundFiles: []
     };
   }
@@ -2273,17 +2549,14 @@ function exportConfig(targetDir) {
   ensureDir(targetDir);
   const ccmanDir2 = getCcmanDir();
   const exportedFiles = [];
-  const codexSrc = path11.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const codexDst = path11.join(targetDir, CODEX_CONFIG_FILE);
-  if (fileExists(codexSrc)) {
-    fs10.copyFileSync(codexSrc, codexDst);
-    exportedFiles.push(CODEX_CONFIG_FILE);
-  }
-  const claudeSrc = path11.join(ccmanDir2, CLAUDE_CONFIG_FILE);
-  const claudeDst = path11.join(targetDir, CLAUDE_CONFIG_FILE);
-  if (fileExists(claudeSrc)) {
-    fs10.copyFileSync(claudeSrc, claudeDst);
-    exportedFiles.push(CLAUDE_CONFIG_FILE);
+  const filesToExport = validation.foundFiles || [];
+  for (const file of filesToExport) {
+    const src = path12.join(ccmanDir2, file);
+    const dst = path12.join(targetDir, file);
+    if (fileExists(src)) {
+      fs11.copyFileSync(src, dst);
+      exportedFiles.push(file);
+    }
   }
   return {
     success: true,
@@ -2301,25 +2574,15 @@ function importConfig(sourceDir) {
   const importedFiles = [];
   ensureDir(ccmanDir2);
   try {
-    if (validation.foundFiles.includes(CODEX_CONFIG_FILE)) {
-      const codexDst = path11.join(ccmanDir2, CODEX_CONFIG_FILE);
-      if (fileExists(codexDst)) {
-        const backupPath = backupConfig(codexDst);
-        backupPaths.push(backupPath);
-      }
-      const codexSrc = path11.join(sourceDir, CODEX_CONFIG_FILE);
-      fs10.copyFileSync(codexSrc, codexDst);
-      importedFiles.push(CODEX_CONFIG_FILE);
-    }
-    if (validation.foundFiles.includes(CLAUDE_CONFIG_FILE)) {
-      const claudeDst = path11.join(ccmanDir2, CLAUDE_CONFIG_FILE);
-      if (fileExists(claudeDst)) {
-        const backupPath = backupConfig(claudeDst);
+    for (const file of validation.foundFiles) {
+      const targetPath = path12.join(ccmanDir2, file);
+      const sourcePath = path12.join(sourceDir, file);
+      if (fileExists(targetPath)) {
+        const backupPath = backupConfig(targetPath);
         backupPaths.push(backupPath);
       }
-      const claudeSrc = path11.join(sourceDir, CLAUDE_CONFIG_FILE);
-      fs10.copyFileSync(claudeSrc, claudeDst);
-      importedFiles.push(CLAUDE_CONFIG_FILE);
+      fs11.copyFileSync(sourcePath, targetPath);
+      importedFiles.push(file);
     }
     return {
       success: true,
@@ -2330,26 +2593,25 @@ function importConfig(sourceDir) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
       if (fileExists(backupPath)) {
-        fs10.copyFileSync(backupPath, originalPath);
+        fs11.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u5BFC\u5165\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
   }
 }
-var CODEX_CONFIG_FILE, CLAUDE_CONFIG_FILE;
+var SUPPORTED_CONFIG_FILES;
 var init_export = __esm({
   "../core/dist/export.js"() {
     "use strict";
     init_paths();
     init_file();
     init_merge();
-    CODEX_CONFIG_FILE = "codex.json";
-    CLAUDE_CONFIG_FILE = "claude.json";
+    SUPPORTED_CONFIG_FILES = ["codex.json", "claude.json", "openclaw.json"];
   }
 });
 
 // ../core/dist/claude-clean.js
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 function formatBytes(bytes) {
   if (bytes < 1024)
     return `${bytes} B`;
@@ -2359,7 +2621,7 @@ function formatBytes(bytes) {
 }
 function getFileSize(filePath) {
   try {
-    const stats = fs11.statSync(filePath);
+    const stats = fs12.statSync(filePath);
     return stats.size;
   } catch {
     return 0;
@@ -2368,18 +2630,18 @@ function getFileSize(filePath) {
 function backupFile2(filePath) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").split(".")[0];
   const backupPath = `${filePath}.backup-${timestamp}`;
-  fs11.copyFileSync(filePath, backupPath);
+  fs12.copyFileSync(filePath, backupPath);
   return backupPath;
 }
 function saveJsonAtomic(filePath, data) {
   const tempPath = `${filePath}.tmp`;
   const content = JSON.stringify(data, null, 2);
-  fs11.writeFileSync(tempPath, content, { mode: 384 });
-  fs11.renameSync(tempPath, filePath);
+  fs12.writeFileSync(tempPath, content, { mode: 384 });
+  fs12.renameSync(tempPath, filePath);
 }
 function analyzeClaudeJson() {
   const filePath = getClaudeJsonPath();
-  if (!fs11.existsSync(filePath)) {
+  if (!fs12.existsSync(filePath)) {
     return {
       fileSize: 0,
       fileSizeFormatted: "0 B",
@@ -2395,7 +2657,7 @@ function analyzeClaudeJson() {
     };
   }
   const fileSize = getFileSize(filePath);
-  const content = fs11.readFileSync(filePath, "utf-8");
+  const content = fs12.readFileSync(filePath, "utf-8");
   const config = JSON.parse(content);
   const projects = config.projects || {};
   const projectHistory = [];
@@ -2429,12 +2691,12 @@ function analyzeClaudeJson() {
 }
 function cleanClaudeJson(options = {}) {
   const filePath = getClaudeJsonPath();
-  if (!fs11.existsSync(filePath)) {
+  if (!fs12.existsSync(filePath)) {
     throw new Error(`${filePath} \u6587\u4EF6\u4E0D\u5B58\u5728`);
   }
   const backupPath = backupFile2(filePath);
   const sizeBefore = getFileSize(filePath);
-  const content = fs11.readFileSync(filePath, "utf-8");
+  const content = fs12.readFileSync(filePath, "utf-8");
   const config = JSON.parse(content);
   const cleanedItems = applyCleanOptions(config, options);
   saveJsonAtomic(filePath, config);
@@ -2522,6 +2784,7 @@ var init_dist2 = __esm({
     init_mcp2();
     init_gemini();
     init_opencode();
+    init_openclaw();
     init_mcp();
     init_migrate();
     init_paths();
@@ -2889,12 +3152,18 @@ function uploadCommand(program2) {
       }
       const codexManager = createCodexManager();
       const claudeManager = createClaudeManager();
+      const geminiManager = createGeminiManager();
+      const openclawManager = createOpenClawManager();
       const codexProviders = codexManager.list();
       const claudeProviders = claudeManager.list();
+      const geminiProviders = geminiManager.list();
+      const openclawProviders = openclawManager.list();
       console.log(chalk6.bold("\n\u{1F4E4} \u4E0A\u4F20\u914D\u7F6E\u5230\u4E91\u7AEF\n"));
       console.log("\u914D\u7F6E\u4FE1\u606F:");
       console.log(`  Codex \u670D\u52A1\u5546: ${chalk6.cyan(codexProviders.length)} \u4E2A`);
       console.log(`  Claude \u670D\u52A1\u5546: ${chalk6.cyan(claudeProviders.length)} \u4E2A`);
+      console.log(`  Gemini \u670D\u52A1\u5546: ${chalk6.cyan(geminiProviders.length)} \u4E2A`);
+      console.log(`  OpenClaw \u670D\u52A1\u5546: ${chalk6.cyan(openclawProviders.length)} \u4E2A`);
       console.log();
       console.log(chalk6.yellow("\u26A0\uFE0F  \u4E91\u7AEF\u73B0\u6709\u914D\u7F6E\u5C06\u88AB\u8986\u76D6"));
       console.log();
@@ -2920,6 +3189,8 @@ function uploadCommand(program2) {
       console.log(chalk6.gray("\u8FDC\u7A0B\u6587\u4EF6:"));
       console.log(chalk6.gray(`  ${config.webdavUrl}${config.remoteDir}/.ccman/codex.json`));
       console.log(chalk6.gray(`  ${config.webdavUrl}${config.remoteDir}/.ccman/claude.json`));
+      console.log(chalk6.gray(`  ${config.webdavUrl}${config.remoteDir}/.ccman/gemini.json`));
+      console.log(chalk6.gray(`  ${config.webdavUrl}${config.remoteDir}/.ccman/openclaw.json`));
       console.log();
       console.log(chalk6.blue("\u{1F4A1} \u5176\u4ED6\u8BBE\u5907\u53EF\u901A\u8FC7 'ccman sync download' \u83B7\u53D6\u914D\u7F6E\n"));
     } catch (error) {
@@ -2990,8 +3261,8 @@ function downloadCommand(program2) {
       console.log();
       if (backupPaths.length > 0) {
         console.log(chalk7.gray("\u672C\u5730\u5907\u4EFD:"));
-        backupPaths.forEach((path14) => {
-          console.log(chalk7.gray(`  ${path14}`));
+        backupPaths.forEach((path15) => {
+          console.log(chalk7.gray(`  ${path15}`));
         });
         console.log();
       }
@@ -3052,8 +3323,8 @@ function mergeCommand(program2) {
       console.log();
       if (result.backupPaths.length > 0) {
         console.log(chalk8.gray("\u5907\u4EFD:"));
-        result.backupPaths.forEach((path14) => {
-          console.log(chalk8.gray(`  ${path14}`));
+        result.backupPaths.forEach((path15) => {
+          console.log(chalk8.gray(`  ${path15}`));
         });
         console.log();
       }
@@ -3098,16 +3369,26 @@ function statusCommand(program2) {
       console.log(`  URL: ${chalk9.gray(config.webdavUrl)}`);
       console.log(`  \u7528\u6237: ${chalk9.gray(config.username)}`);
       console.log(`  \u8FDC\u7A0B\u76EE\u5F55: ${chalk9.gray(config.remoteDir)}`);
-      console.log(`  \u8BA4\u8BC1: ${chalk9.gray(config.authType === "password" ? "Basic Auth" : "Digest Auth")}`);
-      console.log(`  \u540C\u6B65\u5BC6\u7801: ${config.syncPassword ? chalk9.green("\u2713 \u5DF2\u4FDD\u5B58") : chalk9.yellow("\u2717 \u672A\u4FDD\u5B58")}`);
+      console.log(
+        `  \u8BA4\u8BC1: ${chalk9.gray(config.authType === "password" ? "Basic Auth" : "Digest Auth")}`
+      );
+      console.log(
+        `  \u540C\u6B65\u5BC6\u7801: ${config.syncPassword ? chalk9.green("\u2713 \u5DF2\u4FDD\u5B58") : chalk9.yellow("\u2717 \u672A\u4FDD\u5B58")}`
+      );
       console.log();
       const codexManager = createCodexManager();
       const claudeManager = createClaudeManager();
+      const geminiManager = createGeminiManager();
+      const openclawManager = createOpenClawManager();
       const codexProviders = codexManager.list();
       const claudeProviders = claudeManager.list();
+      const geminiProviders = geminiManager.list();
+      const openclawProviders = openclawManager.list();
       console.log(chalk9.bold("\u672C\u5730\u914D\u7F6E:"));
       console.log(`  Codex: ${chalk9.cyan(codexProviders.length)} \u4E2A\u670D\u52A1\u5546`);
       console.log(`  Claude: ${chalk9.cyan(claudeProviders.length)} \u4E2A\u670D\u52A1\u5546`);
+      console.log(`  Gemini: ${chalk9.cyan(geminiProviders.length)} \u4E2A\u670D\u52A1\u5546`);
+      console.log(`  OpenClaw: ${chalk9.cyan(openclawProviders.length)} \u4E2A\u670D\u52A1\u5546`);
       if (config.lastSync) {
         const date = new Date(config.lastSync).toLocaleString("zh-CN");
         console.log(`  \u6700\u540E\u540C\u6B65: ${chalk9.gray(date)}`);
@@ -3245,7 +3526,7 @@ var init_sync = __esm({
 
 // src/index.ts
 import { Command as Command3 } from "commander";
-import chalk48 from "chalk";
+import chalk55 from "chalk";
 
 // src/utils/logo.ts
 init_dist2();
@@ -3308,7 +3589,8 @@ var CLI_TOOL_CONFIG = {
   [TOOL_TYPES.CODEX]: { name: "Codex", emoji: "\u{1F536}", cmd: "cx" },
   [TOOL_TYPES.CLAUDE]: { name: "Claude", emoji: "\u{1F537}", cmd: "cc" },
   [TOOL_TYPES.GEMINI]: { name: "Gemini", emoji: "\u{1F48E}", cmd: "gm" },
-  [TOOL_TYPES.OPENCODE]: { name: "OpenCode", emoji: "\u{1F9E9}", cmd: "oc" }
+  [TOOL_TYPES.OPENCODE]: { name: "OpenCode", emoji: "\u{1F9E9}", cmd: "oc" },
+  [TOOL_TYPES.OPENCLAW]: { name: "OpenClaw", emoji: "\u{1F980}", cmd: "ow" }
 };
 function getManager(tool) {
   switch (tool) {
@@ -3320,6 +3602,8 @@ function getManager(tool) {
       return createGeminiManager();
     case TOOL_TYPES.OPENCODE:
       return createOpenCodeManager();
+    case TOOL_TYPES.OPENCLAW:
+      return createOpenClawManager();
   }
 }
 async function promptProviderForm(defaults) {
@@ -3386,6 +3670,7 @@ async function startMainMenu() {
           { name: "\u{1F536} Codex \u7BA1\u7406", value: "codex" },
           { name: "\u{1F48E} Gemini \u7BA1\u7406", value: "gemini" },
           { name: "\u{1F9E9} OpenCode \u7BA1\u7406", value: "opencode" },
+          { name: "\u{1F980} OpenClaw \u7BA1\u7406", value: "openclaw" },
           { name: "\u{1F504} WebDAV \u540C\u6B65", value: "sync" },
           { name: "\u{1F4E6} \u9884\u7F6E\u670D\u52A1\u5546\u7BA1\u7406", value: "presets" },
           { name: "\u274C \u9000\u51FA", value: "exit" }
@@ -3404,6 +3689,8 @@ async function startMainMenu() {
       await startGeminiMenu();
     } else if (choice === "opencode") {
       await startOpenCodeMenu();
+    } else if (choice === "openclaw") {
+      await startOpenClawMenu();
     } else if (choice === "sync") {
       const { startSyncMenu: startSyncMenu2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
       await startSyncMenu2();
@@ -3424,6 +3711,9 @@ async function startGeminiMenu() {
 async function startOpenCodeMenu() {
   await showToolMenu(TOOL_TYPES.OPENCODE);
 }
+async function startOpenClawMenu() {
+  await showToolMenu(TOOL_TYPES.OPENCLAW);
+}
 async function showToolMenu(tool) {
   const { name: toolName, emoji: toolEmoji } = CLI_TOOL_CONFIG[tool];
   while (true) {
@@ -5275,7 +5565,7 @@ function editCommand3(program2) {
         targetId = selectedId;
       }
       const provider = manager.get(targetId);
-      const currentCommand5 = provider.baseUrl;
+      const currentCommand6 = provider.baseUrl;
       const currentArgs = provider.apiKey;
       const currentEnv = provider.model;
       console.log(chalk30.bold("\n\u270F\uFE0F  \u7F16\u8F91 MCP \u670D\u52A1\u5668\n"));
@@ -5291,7 +5581,7 @@ function editCommand3(program2) {
           type: "input",
           name: "command",
           message: "\u542F\u52A8\u547D\u4EE4:",
-          default: currentCommand5
+          default: currentCommand6
         },
         {
           type: "input",
@@ -5310,7 +5600,7 @@ function editCommand3(program2) {
       if (answers.name && answers.name !== provider.name) {
         updates.name = answers.name;
       }
-      if (answers.command && answers.command !== currentCommand5) {
+      if (answers.command && answers.command !== currentCommand6) {
         updates.baseUrl = answers.command;
       }
       if (answers.args && answers.args !== currentArgs) {
@@ -6241,44 +6531,495 @@ function createOpenCodeCommands(program2) {
   cloneCommand4(program2);
 }
 
+// src/commands/openclaw/add.ts
+init_dist2();
+import chalk45 from "chalk";
+import inquirer32 from "inquirer";
+function addCommand6(program2) {
+  program2.command("add").description("\u6DFB\u52A0\u65B0\u7684 OpenClaw \u670D\u52A1\u5546(\u4EA4\u4E92\u5F0F)").action(async () => {
+    try {
+      const manager = createOpenClawManager();
+      console.log(chalk45.bold("\n\u{1F4DD} \u6DFB\u52A0 OpenClaw \u670D\u52A1\u5546\n"));
+      const { usePreset } = await inquirer32.prompt([
+        {
+          type: "list",
+          name: "usePreset",
+          message: "\u9009\u62E9\u914D\u7F6E\u6765\u6E90:",
+          choices: [
+            { name: "\u{1F4E6} \u4F7F\u7528\u9884\u7F6E\u670D\u52A1\u5546", value: true },
+            { name: "\u270F\uFE0F  \u81EA\u5B9A\u4E49\u914D\u7F6E", value: false }
+          ]
+        }
+      ]);
+      let name;
+      let desc;
+      let baseUrl;
+      let apiKey;
+      if (usePreset) {
+        const { presetName } = await inquirer32.prompt([
+          {
+            type: "list",
+            name: "presetName",
+            message: "\u9009\u62E9\u9884\u7F6E\u670D\u52A1\u5546:",
+            choices: OPENCLAW_PRESETS.map((p) => ({
+              name: `${p.name} - ${p.description}`,
+              value: p.name
+            }))
+          }
+        ]);
+        const preset = OPENCLAW_PRESETS.find((p) => p.name === presetName);
+        console.log(chalk45.blue(`
+\u4F7F\u7528\u9884\u8BBE: ${preset.name} - ${preset.description}
+`));
+        const input = await promptProviderForm({
+          name: preset.name,
+          desc: "",
+          baseUrl: preset.baseUrl,
+          apiKey: ""
+        });
+        name = input.name;
+        desc = input.desc;
+        baseUrl = input.baseUrl;
+        apiKey = input.apiKey;
+      } else {
+        const answers = await inquirer32.prompt([
+          {
+            type: "input",
+            name: "name",
+            message: "\u670D\u52A1\u5546\u540D\u79F0:",
+            validate: (value) => value ? true : "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"
+          },
+          {
+            type: "input",
+            name: "baseUrl",
+            message: "API \u5730\u5740:",
+            validate: (value) => {
+              if (!value) return "API \u5730\u5740\u4E0D\u80FD\u4E3A\u7A7A";
+              if (!value.startsWith("http://") && !value.startsWith("https://")) {
+                return "API \u5730\u5740\u5FC5\u987B\u4EE5 http:// \u6216 https:// \u5F00\u5934";
+              }
+              return true;
+            }
+          },
+          {
+            type: "password",
+            name: "apiKey",
+            message: "API \u5BC6\u94A5:",
+            mask: "*",
+            validate: (value) => value ? true : "API \u5BC6\u94A5\u4E0D\u80FD\u4E3A\u7A7A"
+          }
+        ]);
+        name = answers.name;
+        desc = void 0;
+        baseUrl = answers.baseUrl;
+        apiKey = answers.apiKey;
+      }
+      const provider = manager.add({
+        name,
+        desc,
+        baseUrl,
+        apiKey
+      });
+      console.log();
+      console.log(chalk45.green("\u2705 \u6DFB\u52A0\u6210\u529F"));
+      console.log();
+      console.log(`  ${chalk45.bold(provider.name)} ${chalk45.blue("[OpenClaw]")}`);
+      console.log(`  ${chalk45.gray(provider.baseUrl)}`);
+      console.log();
+      const { switchNow } = await inquirer32.prompt([
+        {
+          type: "confirm",
+          name: "switchNow",
+          message: "\u662F\u5426\u7ACB\u5373\u5207\u6362\u5230\u6B64\u670D\u52A1\u5546?",
+          default: true
+        }
+      ]);
+      if (switchNow) {
+        manager.switch(provider.id);
+        console.log(chalk45.green("\u2705 \u5DF2\u5207\u6362\u5230\u65B0\u670D\u52A1\u5546"));
+        console.log();
+        console.log(chalk45.gray("\u914D\u7F6E\u5DF2\u66F4\u65B0:"));
+        console.log(chalk45.gray(`  - ${getOpenClawConfigPath()}`));
+        console.log(chalk45.gray(`  - ${getOpenClawModelsPath()}`));
+      } else {
+        console.log(
+          chalk45.blue("\u{1F4A1} \u7A0D\u540E\u5207\u6362:") + chalk45.white(` ccman openclaw use "${provider.name}"`)
+        );
+      }
+    } catch (error) {
+      console.error(chalk45.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/openclaw/list.ts
+init_dist2();
+import chalk46 from "chalk";
+function listCommand6(program2) {
+  program2.command("list").alias("ls").description("\u5217\u51FA\u6240\u6709 OpenClaw \u670D\u52A1\u5546").action(async () => {
+    try {
+      const manager = createOpenClawManager();
+      const providers = manager.list();
+      const current = manager.getCurrent();
+      if (providers.length === 0) {
+        console.log(chalk46.yellow("\n\u26A0\uFE0F  \u6682\u65E0 OpenClaw \u670D\u52A1\u5546\n"));
+        console.log(chalk46.blue("\u{1F4A1} \u6DFB\u52A0\u670D\u52A1\u5546:") + chalk46.white(" ccman openclaw add\n"));
+        return;
+      }
+      console.log(chalk46.bold(`
+\u{1F4CB} OpenClaw \u670D\u52A1\u5546 (${providers.length} \u4E2A)`));
+      console.log(formatProviderTable(providers, current?.id));
+    } catch (error) {
+      console.error(chalk46.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/openclaw/use.ts
+init_dist2();
+import chalk47 from "chalk";
+import inquirer33 from "inquirer";
+function useCommand5(program2) {
+  program2.command("use [name]").description("\u5207\u6362 OpenClaw \u670D\u52A1\u5546").action(async (name) => {
+    try {
+      const manager = createOpenClawManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(chalk47.yellow("\n\u26A0\uFE0F  \u6682\u65E0 OpenClaw \u670D\u52A1\u5546\n"));
+        console.log(chalk47.blue("\u{1F4A1} \u6DFB\u52A0\u670D\u52A1\u5546:") + chalk47.white(" ccman openclaw add\n"));
+        return;
+      }
+      let targetId;
+      if (name) {
+        const provider2 = manager.findByName(name);
+        if (!provider2) {
+          throw new ProviderNotFoundError(name);
+        }
+        targetId = provider2.id;
+      } else {
+        const { selectedId } = await inquirer33.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u5207\u6362\u7684\u670D\u52A1\u5546:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl}`,
+              value: p.id
+            }))
+          }
+        ]);
+        targetId = selectedId;
+      }
+      manager.switch(targetId);
+      const provider = manager.get(targetId);
+      console.log(chalk47.green("\n\u2705 \u5207\u6362\u6210\u529F\n"));
+      console.log(`  ${chalk47.bold(provider.name)} ${chalk47.blue("[OpenClaw]")}`);
+      console.log(`  ${chalk47.gray(`URL: ${provider.baseUrl}`)}`);
+      console.log();
+      console.log(chalk47.gray("\u914D\u7F6E\u5DF2\u66F4\u65B0:"));
+      console.log(chalk47.gray(`  - ${getOpenClawConfigPath()}`));
+      console.log(chalk47.gray(`  - ${getOpenClawModelsPath()}`));
+    } catch (error) {
+      if (error instanceof ProviderNotFoundError) {
+        console.error(chalk47.red(`
+\u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${name}
+`));
+      } else {
+        console.error(chalk47.red(`
+\u274C ${error.message}
+`));
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/openclaw/current.ts
+init_dist2();
+import chalk48 from "chalk";
+function currentCommand5(program2) {
+  program2.command("current").description("\u663E\u793A\u5F53\u524D OpenClaw \u670D\u52A1\u5546").action(async () => {
+    try {
+      const manager = createOpenClawManager();
+      const current = manager.getCurrent();
+      if (!current) {
+        console.log(chalk48.yellow("\n\u26A0\uFE0F  \u5F53\u524D\u6CA1\u6709\u6FC0\u6D3B\u7684 OpenClaw \u670D\u52A1\u5546\n"));
+        console.log(chalk48.blue("\u{1F4A1} \u5217\u51FA\u670D\u52A1\u5546:") + chalk48.white(" ccman openclaw list\n"));
+        return;
+      }
+      console.log(chalk48.bold("\n\u{1F3AF} \u5F53\u524D OpenClaw \u670D\u52A1\u5546\n"));
+      console.log(`  \u540D\u79F0: ${chalk48.bold(current.name)}`);
+      console.log(`  \u5730\u5740: ${chalk48.gray(current.baseUrl)}`);
+      console.log();
+    } catch (error) {
+      console.error(chalk48.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/openclaw/edit.ts
+init_dist2();
+import chalk49 from "chalk";
+import inquirer34 from "inquirer";
+function editCommand6(program2) {
+  program2.command("edit [name]").description("\u7F16\u8F91 OpenClaw \u670D\u52A1\u5546").action(async (name) => {
+    try {
+      const manager = createOpenClawManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(chalk49.yellow("\n\u26A0\uFE0F  \u6682\u65E0 OpenClaw \u670D\u52A1\u5546\n"));
+        console.log(chalk49.blue("\u{1F4A1} \u6DFB\u52A0\u670D\u52A1\u5546:") + chalk49.white(" ccman openclaw add\n"));
+        return;
+      }
+      let targetId;
+      if (name) {
+        const provider2 = manager.findByName(name);
+        if (!provider2) {
+          throw new ProviderNotFoundError(name);
+        }
+        targetId = provider2.id;
+      } else {
+        const { selectedId } = await inquirer34.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u7F16\u8F91\u7684\u670D\u52A1\u5546:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl}`,
+              value: p.id
+            }))
+          }
+        ]);
+        targetId = selectedId;
+      }
+      const provider = manager.get(targetId);
+      const input = await promptProviderForm({
+        name: provider.name,
+        desc: provider.desc ?? "",
+        baseUrl: provider.baseUrl,
+        apiKey: provider.apiKey
+      });
+      manager.edit(targetId, {
+        name: input.name,
+        desc: input.desc,
+        baseUrl: input.baseUrl,
+        apiKey: input.apiKey
+      });
+      console.log(chalk49.green("\n\u2705 \u7F16\u8F91\u6210\u529F\n"));
+    } catch (error) {
+      if (error instanceof ProviderNotFoundError) {
+        console.error(chalk49.red(`
+\u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${name}
+`));
+      } else {
+        console.error(chalk49.red(`
+\u274C ${error.message}
+`));
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/openclaw/remove.ts
+init_dist2();
+import chalk50 from "chalk";
+import inquirer35 from "inquirer";
+function removeCommand6(program2) {
+  program2.command("remove [name]").alias("rm").description("\u5220\u9664 OpenClaw \u670D\u52A1\u5546").action(async (name) => {
+    try {
+      const manager = createOpenClawManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(chalk50.yellow("\n\u26A0\uFE0F  \u6682\u65E0 OpenClaw \u670D\u52A1\u5546\n"));
+        return;
+      }
+      let targetId;
+      let targetName;
+      if (name) {
+        const provider = manager.findByName(name);
+        if (!provider) {
+          throw new ProviderNotFoundError(name);
+        }
+        targetId = provider.id;
+        targetName = provider.name;
+      } else {
+        const { selectedId } = await inquirer35.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u5220\u9664\u7684\u670D\u52A1\u5546:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl}`,
+              value: p.id
+            }))
+          }
+        ]);
+        const provider = manager.get(selectedId);
+        targetId = selectedId;
+        targetName = provider.name;
+      }
+      const { confirmed } = await inquirer35.prompt([
+        {
+          type: "confirm",
+          name: "confirmed",
+          message: `\u786E\u5B9A\u5220\u9664 "${targetName}"?`,
+          default: false
+        }
+      ]);
+      if (!confirmed) {
+        console.log(chalk50.gray("\n\u5DF2\u53D6\u6D88\n"));
+        return;
+      }
+      manager.remove(targetId);
+      console.log(chalk50.green(`
+\u2705 \u5DF2\u5220\u9664: ${targetName}
+`));
+    } catch (error) {
+      if (error instanceof ProviderNotFoundError) {
+        console.error(chalk50.red(`
+\u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${name}
+`));
+      } else {
+        console.error(chalk50.red(`
+\u274C ${error.message}
+`));
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/openclaw/clone.ts
+init_dist2();
+import chalk51 from "chalk";
+import inquirer36 from "inquirer";
+function cloneCommand5(program2) {
+  program2.command("clone [source-name] [new-name]").description("\u514B\u9686 OpenClaw \u670D\u52A1\u5546").action(async (sourceName, newName) => {
+    try {
+      const manager = createOpenClawManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(chalk51.yellow("\n\u26A0\uFE0F  \u6682\u65E0 OpenClaw \u670D\u52A1\u5546\n"));
+        return;
+      }
+      let sourceId;
+      if (sourceName) {
+        const provider = manager.findByName(sourceName);
+        if (!provider) {
+          throw new ProviderNotFoundError(sourceName);
+        }
+        sourceId = provider.id;
+      } else {
+        const { selectedId } = await inquirer36.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u514B\u9686\u7684\u670D\u52A1\u5546:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl}`,
+              value: p.id
+            }))
+          }
+        ]);
+        sourceId = selectedId;
+      }
+      const source = manager.get(sourceId);
+      let cloned;
+      if (newName) {
+        cloned = manager.clone(sourceId, newName);
+      } else {
+        console.log(chalk51.blue(`
+\u514B\u9686\u81EA: ${source.name}
+`));
+        const input = await promptProviderForm({
+          name: `${source.name}\uFF08\u526F\u672C\uFF09`,
+          desc: "",
+          baseUrl: source.baseUrl,
+          apiKey: source.apiKey
+        });
+        cloned = manager.add({
+          name: input.name,
+          desc: input.desc,
+          baseUrl: input.baseUrl,
+          apiKey: input.apiKey
+        });
+      }
+      console.log();
+      console.log(chalk51.green("\u2705 \u514B\u9686\u6210\u529F"));
+      console.log();
+      console.log(`  ${chalk51.bold(cloned.name)} ${chalk51.blue("[OpenClaw]")}`);
+      console.log(`  ${chalk51.gray(`ID: ${cloned.id}`)}`);
+      console.log(`  ${chalk51.gray(`URL: ${cloned.baseUrl}`)}`);
+      console.log();
+    } catch (error) {
+      console.error(chalk51.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/openclaw/index.ts
+function createOpenClawCommands(program2) {
+  addCommand6(program2);
+  listCommand6(program2);
+  useCommand5(program2);
+  currentCommand5(program2);
+  editCommand6(program2);
+  removeCommand6(program2);
+  cloneCommand5(program2);
+}
+
 // src/index.ts
 init_sync();
 
 // src/commands/export.ts
 init_dist2();
-import chalk45 from "chalk";
-import path12 from "path";
+import chalk52 from "chalk";
+import path13 from "path";
 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(chalk45.bold("\n\u{1F4E6} \u5BFC\u51FA\u914D\u7F6E\n"));
+      console.log(chalk52.bold("\n\u{1F4E6} \u5BFC\u51FA\u914D\u7F6E\n"));
       const validation = validateExport();
       if (!validation.valid) {
-        console.log(chalk45.red(`\u274C ${validation.message}
+        console.log(chalk52.red(`\u274C ${validation.message}
 `));
         process.exit(1);
       }
-      const resolvedPath = targetDir.startsWith("~") ? path12.join(process.env.HOME || "", targetDir.slice(1)) : path12.resolve(targetDir);
-      console.log("\u5BFC\u51FA\u6587\u4EF6:");
-      console.log(`  ${chalk45.cyan("codex.json")}  - Codex \u914D\u7F6E`);
-      console.log(`  ${chalk45.cyan("claude.json")} - Claude \u914D\u7F6E`);
+      const resolvedPath = targetDir.startsWith("~") ? path13.join(process.env.HOME || "", targetDir.slice(1)) : path13.resolve(targetDir);
+      console.log("\u5BFC\u51FA\u6587\u4EF6\uFF08\u5B58\u5728\u5219\u5BFC\u51FA\uFF0C\u4E0D\u5B58\u5728\u5219\u8DF3\u8FC7\uFF09:");
+      console.log(`  ${chalk52.cyan("codex.json")}    - Codex \u914D\u7F6E`);
+      console.log(`  ${chalk52.cyan("claude.json")}   - Claude \u914D\u7F6E`);
+      console.log(`  ${chalk52.cyan("openclaw.json")} - OpenClaw \u914D\u7F6E`);
       console.log();
-      console.log(`\u76EE\u6807\u76EE\u5F55: ${chalk45.cyan(resolvedPath)}`);
+      console.log(`\u76EE\u6807\u76EE\u5F55: ${chalk52.cyan(resolvedPath)}`);
       console.log();
-      console.log(chalk45.yellow("\u26A0\uFE0F  \u5BFC\u51FA\u6587\u4EF6\u5305\u542B API Key\uFF0C\u8BF7\u59A5\u5584\u4FDD\u7BA1"));
+      console.log(chalk52.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(chalk45.green("\u2705 \u5BFC\u51FA\u6210\u529F"));
+      console.log(chalk52.green("\u2705 \u5BFC\u51FA\u6210\u529F"));
       console.log();
       console.log("\u5DF2\u5BFC\u51FA\u6587\u4EF6:");
       for (const file of result.exportedFiles) {
-        console.log(`  ${chalk45.cyan("\u2713")} ${file}`);
+        console.log(`  ${chalk52.cyan("\u2713")} ${file}`);
       }
       console.log();
-      console.log(chalk45.blue(`\u{1F4A1} \u5BFC\u5165\u547D\u4EE4: ccman import ${resolvedPath}
+      console.log(chalk52.blue(`\u{1F4A1} \u5BFC\u5165\u547D\u4EE4: ccman import ${resolvedPath}
 `));
     } catch (error) {
-      console.error(chalk45.red(`
+      console.error(chalk52.red(`
 \u274C ${error.message}
 `));
       process.exit(1);
@@ -6288,31 +7029,33 @@ function exportCommand(program2) {
 
 // src/commands/import.ts
 init_dist2();
-import chalk46 from "chalk";
-import inquirer32 from "inquirer";
-import path13 from "path";
+import chalk53 from "chalk";
+import inquirer37 from "inquirer";
+import path14 from "path";
 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("~") ? path13.join(process.env.HOME || "", sourceDir.slice(1)) : path13.resolve(sourceDir);
-      console.log(chalk46.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
+      const resolvedPath = sourceDir.startsWith("~") ? path14.join(process.env.HOME || "", sourceDir.slice(1)) : path14.resolve(sourceDir);
+      console.log(chalk53.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
       const validation = validateImportDir(resolvedPath);
       if (!validation.valid) {
-        console.log(chalk46.red(`\u274C ${validation.message}
+        console.log(chalk53.red(`\u274C ${validation.message}
 `));
         process.exit(1);
       }
-      console.log(chalk46.yellow("\u26A0\uFE0F  \u8B66\u544A\uFF1A\u5BFC\u5165\u5C06\u8986\u76D6\u5F53\u524D\u914D\u7F6E\n"));
-      console.log(`\u6E90\u76EE\u5F55: ${chalk46.cyan(resolvedPath)}`);
+      console.log(chalk53.yellow("\u26A0\uFE0F  \u8B66\u544A\uFF1A\u5BFC\u5165\u5C06\u8986\u76D6\u5F53\u524D\u914D\u7F6E\n"));
+      console.log(`\u6E90\u76EE\u5F55: ${chalk53.cyan(resolvedPath)}`);
       console.log();
       console.log("\u627E\u5230\u914D\u7F6E\u6587\u4EF6:");
       for (const file of validation.foundFiles) {
-        console.log(`  ${chalk46.cyan("\u2713")} ${file}`);
+        console.log(`  ${chalk53.cyan("\u2713")} ${file}`);
       }
       console.log();
-      console.log(chalk46.gray("\u5F53\u524D\u914D\u7F6E\u5C06\u88AB\u8986\u76D6\uFF08\u81EA\u52A8\u5907\u4EFD\uFF09"));
+      console.log(chalk53.gray("\u672A\u627E\u5230\u7684\u53D7\u652F\u6301\u6587\u4EF6\u5C06\u81EA\u52A8\u8DF3\u8FC7\uFF0C\u4E0D\u4F1A\u4E2D\u65AD\u5BFC\u5165"));
+      console.log();
+      console.log(chalk53.gray("\u5F53\u524D\u914D\u7F6E\u5C06\u88AB\u8986\u76D6\uFF08\u81EA\u52A8\u5907\u4EFD\uFF09"));
       console.log();
-      const { confirmFirst } = await inquirer32.prompt([
+      const { confirmFirst } = await inquirer37.prompt([
         {
           type: "confirm",
           name: "confirmFirst",
@@ -6321,13 +7064,13 @@ function importCommand(program2) {
         }
       ]);
       if (!confirmFirst) {
-        console.log(chalk46.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
+        console.log(chalk53.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
         return;
       }
       console.log();
-      console.log(chalk46.red.bold("\u26A0\uFE0F  \u6700\u540E\u786E\u8BA4\uFF1A\u6B64\u64CD\u4F5C\u5C06\u8986\u76D6\u6240\u6709\u5F53\u524D\u914D\u7F6E\uFF01"));
+      console.log(chalk53.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 inquirer32.prompt([
+      const { confirmSecond } = await inquirer37.prompt([
         {
           type: "confirm",
           name: "confirmSecond",
@@ -6336,31 +7079,31 @@ function importCommand(program2) {
         }
       ]);
       if (!confirmSecond) {
-        console.log(chalk46.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
+        console.log(chalk53.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
         return;
       }
       console.log();
-      console.log(chalk46.gray("\u{1F4BE} \u5907\u4EFD\u5F53\u524D\u914D\u7F6E..."));
-      console.log(chalk46.gray("\u{1F4E5} \u5BFC\u5165\u65B0\u914D\u7F6E..."));
+      console.log(chalk53.gray("\u{1F4BE} \u5907\u4EFD\u5F53\u524D\u914D\u7F6E..."));
+      console.log(chalk53.gray("\u{1F4E5} \u5BFC\u5165\u65B0\u914D\u7F6E..."));
       const result = importConfig(resolvedPath);
       console.log();
-      console.log(chalk46.green("\u2705 \u5BFC\u5165\u6210\u529F"));
+      console.log(chalk53.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(`  ${chalk46.gray(backupPath)}`);
+          console.log(`  ${chalk53.gray(backupPath)}`);
         }
         console.log();
       }
       console.log("\u5DF2\u5BFC\u5165\u6587\u4EF6:");
       for (const file of result.importedFiles) {
-        console.log(`  ${chalk46.cyan("\u2713")} ${file}`);
+        console.log(`  ${chalk53.cyan("\u2713")} ${file}`);
       }
       console.log();
-      console.log(chalk46.blue("\u{1F4A1} \u8BF7\u4F7F\u7528 'ccman cx use' \u6216 'ccman cc use' \u5207\u6362\u670D\u52A1\u5546\n"));
+      console.log(chalk53.blue("\u{1F4A1} \u8BF7\u4F7F\u7528 'ccman cx use' \u6216 'ccman cc use' \u5207\u6362\u670D\u52A1\u5546\n"));
     } catch (error) {
-      console.error(chalk46.red(`
+      console.error(chalk53.red(`
 \u274C ${error.message}
 `));
       process.exit(1);
@@ -6370,16 +7113,13 @@ function importCommand(program2) {
 
 // src/commands/gmn.ts
 init_dist2();
-import chalk47 from "chalk";
-import inquirer33 from "inquirer";
+import chalk54 from "chalk";
+import inquirer38 from "inquirer";
 var PROVIDER_NAME = "GMN";
-var VALID_PLATFORMS = ["claude", "codex", "gemini", "opencode"];
+var VALID_PLATFORMS = ["codex", "opencode", "openclaw"];
 var DEFAULT_PLATFORMS = ["codex", "opencode"];
-var GMN_BASE_URLS = {
-  claude: "https://gmn.chuangzuoli.com/api",
-  gemini: "https://gmn.chuangzuoli.com"
-};
 var GMN_OPENAI_BASE_URL = "https://gmn.chuangzuoli.com";
+var GMN_OPENCLAW_BASE_URL = "https://gmn.chuangzuoli.com/v1";
 var TOTAL_STEPS = 3;
 function renderStep(current, total, title) {
   const barLength = total;
@@ -6390,7 +7130,7 @@ function renderStep(current, total, title) {
 function printBanner() {
   printLogo();
   console.log(
-    chalk47.cyanBright(
+    chalk54.cyanBright(
       [
         "  \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557",
         " \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D  \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551",
@@ -6402,39 +7142,36 @@ function printBanner() {
       ].join("\n")
     )
   );
-  console.log(chalk47.gray("\u81EA\u52A8\u5199\u5165\u9009\u4E2D\u5DE5\u5177\u914D\u7F6E\uFF0C\u652F\u6301\u591A\u9009\u3002\n"));
+  console.log(chalk54.gray("\u81EA\u52A8\u5199\u5165\u9009\u4E2D\u5DE5\u5177\u914D\u7F6E\uFF0C\u652F\u6301\u591A\u9009\u3002\n"));
 }
 function printKeyNotice() {
   console.log(
-    chalk47.yellow(
+    chalk54.yellow(
       [
-        "\u63D0\u793A\uFF1ACodex \u4E0E OpenCode \u5171\u4EAB OpenAI \u5957\u9910/\u7AEF\u70B9\uFF1BGemini \u4E0E Claude \u9700\u5355\u72EC\u8BA2\u9605\u3002",
-        "\u4F8B\u5982\uFF1AGemini \u5957\u9910\u4E0D\u80FD\u7528\u4E8E Codex/OpenCode\uFF0CClaude \u5957\u9910\u4E5F\u4E0D\u80FD\u901A\u7528\u3002",
+        "\u63D0\u793A\uFF1A\u672C\u547D\u4EE4\u652F\u6301 Codex\u3001OpenCode\u3001OpenClaw \u4E09\u4E2A\u5E73\u53F0\u3002",
+        "Codex \u4E0E OpenCode \u5171\u4EAB OpenAI \u7AEF\u70B9\uFF1BOpenClaw \u4F7F\u7528 /v1 \u7AEF\u70B9\u3002",
         "VS Code \u7684 Codex \u63D2\u4EF6\u82E5\u4F7F\u7528\u672C\u673A\u9ED8\u8BA4\u914D\u7F6E\uFF0C\u4E5F\u4F1A\u8DDF\u968F\u672C\u6B21\u5199\u5165\u751F\u6548\u3002"
       ].join("\n")
     )
   );
 }
 function printWriteTargets(platforms) {
-  console.log(chalk47.gray(`\u5199\u5165\u76EE\u5F55: ${getCcmanDir()}`));
+  console.log(chalk54.gray(`\u5199\u5165\u76EE\u5F55: ${getCcmanDir()}`));
   if (platforms.includes("codex")) {
-    console.log(chalk47.gray(`  - Codex: ${getCodexConfigPath()}`));
-    console.log(chalk47.gray(`  - Codex: ${getCodexAuthPath()}`));
-  }
-  if (platforms.includes("claude")) {
-    console.log(chalk47.gray(`  - Claude Code: ${getClaudeConfigPath()}`));
-  }
-  if (platforms.includes("gemini")) {
-    console.log(chalk47.gray(`  - Gemini CLI: ${getGeminiSettingsPath()}`));
-    console.log(chalk47.gray(`  - Gemini CLI: ${getGeminiEnvPath()}`));
+    console.log(chalk54.gray(`  - Codex: ${getCodexConfigPath()}`));
+    console.log(chalk54.gray(`  - Codex: ${getCodexAuthPath()}`));
   }
   if (platforms.includes("opencode")) {
-    console.log(chalk47.gray(`  - OpenCode: ${getOpenCodeConfigPath()}`));
+    console.log(chalk54.gray(`  - OpenCode: ${getOpenCodeConfigPath()}`));
+  }
+  if (platforms.includes("openclaw")) {
+    console.log(chalk54.gray(`  - OpenClaw: ${getOpenClawConfigPath()}`));
+    console.log(chalk54.gray(`  - OpenClaw: ${getOpenClawModelsPath()}`));
   }
   const env = process.env.NODE_ENV;
   if (env === "development" || env === "test") {
     console.log(
-      chalk47.yellow(
+      chalk54.yellow(
         `\u26A0\uFE0F \u5F53\u524D NODE_ENV=${env}\uFF0C\u5C06\u5199\u5165\u5F00\u53D1/\u6D4B\u8BD5\u76EE\u5F55\uFF1B\u5982\u9700\u5199\u5165\u771F\u5B9E HOME\uFF0C\u8BF7\u5728\u751F\u4EA7\u73AF\u5883\u8FD0\u884C\uFF08unset NODE_ENV\uFF09\u3002`
       )
     );
@@ -6453,7 +7190,7 @@ function parsePlatforms(platformArg) {
   return platforms;
 }
 async function promptApiKey() {
-  const answers = await inquirer33.prompt([
+  const answers = await inquirer38.prompt([
     {
       type: "password",
       name: "apiKey",
@@ -6468,18 +7205,17 @@ async function promptApiKey() {
   return answers.apiKey.trim();
 }
 async function promptPlatforms() {
-  const answers = await inquirer33.prompt([
+  const answers = await inquirer38.prompt([
     {
       type: "checkbox",
       name: "platforms",
       message: "\u9009\u62E9\u8981\u914D\u7F6E\u7684\u5DE5\u5177\uFF08\u53EF\u591A\u9009\uFF0C\u7A7A\u683C\u9009\u62E9 / a\u5168\u9009 / i\u53CD\u9009 / \u56DE\u8F66\u786E\u8BA4\uFF09:",
       dontShowHints: true,
       choices: [
-        { name: "Claude Code\uFF08\u9700\u5355\u72EC\u8BA2\u9605 Claude \u5957\u9910\uFF09", value: "claude" },
         { name: "Codex\uFF08\u9700\u5355\u72EC\u8BA2\u9605 OpenAI \u5957\u9910\uFF09", value: "codex" },
-        { name: "Gemini CLI\uFF08\u9700\u5355\u72EC\u8BA2\u9605 Gemini \u5957\u9910\uFF09", value: "gemini" },
         { name: "OpenCode\uFF08\u4E0E Codex \u5171\u4EAB OpenAI \u5957\u9910\uFF09", value: "opencode" },
-        { name: "\u5168\u90E8\uFF08\u5C06\u4F9D\u6B21\u914D\u7F6E\u6240\u6709\u5DE5\u5177\uFF09", value: "all" }
+        { name: "OpenClaw\uFF08GMN /v1 \u7AEF\u70B9\uFF0C\u9ED8\u8BA4\u4E0D\u9009\u4E2D\uFF09", value: "openclaw" },
+        { name: "\u5168\u90E8\uFF08\u5C06\u4F9D\u6B21\u914D\u7F6E Codex\u3001OpenCode\u3001OpenClaw\uFF09", value: "all" }
       ],
       default: DEFAULT_PLATFORMS,
       validate: (value) => {
@@ -6504,47 +7240,48 @@ async function gmnCommand(apiKey, platformArg) {
   printBanner();
   let platforms;
   try {
-    console.log(chalk47.cyan(`
+    console.log(chalk54.cyan(`
 ${renderStep(1, TOTAL_STEPS, "\u9009\u62E9\u8981\u914D\u7F6E\u7684\u5DE5\u5177")}`));
     platforms = await resolvePlatforms(platformArg);
   } catch (error) {
-    console.error(chalk47.red(`\u274C ${error.message}`));
+    console.error(chalk54.red(`\u274C ${error.message}`));
     process.exit(1);
   }
-  console.log(chalk47.gray(`\u5DF2\u9009\u62E9: ${platforms.join(", ")}`));
+  console.log(chalk54.gray(`\u5DF2\u9009\u62E9: ${platforms.join(", ")}`));
   printKeyNotice();
   let resolvedApiKey = apiKey?.trim();
-  console.log(chalk47.cyan(`
+  console.log(chalk54.cyan(`
 ${renderStep(2, TOTAL_STEPS, "\u8F93\u5165 API Key")}`));
   if (!resolvedApiKey) {
     resolvedApiKey = await promptApiKey();
   } else {
-    console.log(chalk47.gray("\u5DF2\u901A\u8FC7\u53C2\u6570\u63D0\u4F9B API Key\uFF08\u5DF2\u9690\u85CF\uFF09"));
+    console.log(chalk54.gray("\u5DF2\u901A\u8FC7\u53C2\u6570\u63D0\u4F9B API Key\uFF08\u5DF2\u9690\u85CF\uFF09"));
   }
   if (!resolvedApiKey?.trim()) {
-    console.error(chalk47.red("\u274C \u9519\u8BEF: API Key \u4E0D\u80FD\u4E3A\u7A7A"));
+    console.error(chalk54.red("\u274C \u9519\u8BEF: API Key \u4E0D\u80FD\u4E3A\u7A7A"));
     process.exit(1);
   }
   const openaiBaseUrl = GMN_OPENAI_BASE_URL;
   const platformBaseUrls = {
-    claude: GMN_BASE_URLS.claude,
     codex: openaiBaseUrl,
-    gemini: GMN_BASE_URLS.gemini,
-    opencode: openaiBaseUrl
+    opencode: openaiBaseUrl,
+    openclaw: GMN_OPENCLAW_BASE_URL
   };
-  console.log(chalk47.cyan(`
+  console.log(chalk54.cyan(`
 ${renderStep(3, TOTAL_STEPS, "\u5F00\u59CB\u5199\u5165\u914D\u7F6E")}`));
-  console.log(chalk47.gray(`\u5DF2\u9009\u62E9\u5E73\u53F0: ${platforms.join(", ")}`));
+  console.log(chalk54.gray(`\u5DF2\u9009\u62E9\u5E73\u53F0: ${platforms.join(", ")}`));
   if (platforms.includes("codex") || platforms.includes("opencode")) {
-    console.log(chalk47.gray(`OpenAI Base URL: ${openaiBaseUrl}`));
+    console.log(chalk54.gray(`OpenAI Base URL: ${openaiBaseUrl}`));
+  }
+  if (platforms.includes("openclaw")) {
+    console.log(chalk54.gray(`OpenClaw Base URL: ${GMN_OPENCLAW_BASE_URL}`));
   }
   printWriteTargets(platforms);
   console.log();
   const ALL_TOOLS = {
-    claude: { name: "Claude Code", manager: createClaudeManager() },
     codex: { name: "Codex", manager: createCodexManager() },
-    gemini: { name: "Gemini CLI", manager: createGeminiManager() },
-    opencode: { name: "OpenCode", manager: createOpenCodeManager() }
+    opencode: { name: "OpenCode", manager: createOpenCodeManager() },
+    openclaw: { name: "OpenClaw", manager: createOpenClawManager() }
   };
   const tools = platforms.map((platform) => ({
     platform,
@@ -6553,34 +7290,35 @@ ${renderStep(3, TOTAL_STEPS, "\u5F00\u59CB\u5199\u5165\u914D\u7F6E")}`));
   let completed = 0;
   for (const { platform, name, manager } of tools) {
     try {
-      console.log(chalk47.gray(`\u2192 \u914D\u7F6E ${name}...`));
+      console.log(chalk54.gray(`\u2192 \u914D\u7F6E ${name}...`));
       const baseUrl = platformBaseUrls[platform];
       const existing = manager.findByName(PROVIDER_NAME);
       const provider = existing ? manager.edit(existing.id, { baseUrl, apiKey: resolvedApiKey }) : manager.add({ name: PROVIDER_NAME, baseUrl, apiKey: resolvedApiKey });
       manager.switch(provider.id);
       completed += 1;
-      console.log(chalk47.green(`\u2705 ${name}`));
+      console.log(chalk54.green(`\u2705 ${name}`));
     } catch (error) {
-      console.error(chalk47.red(`\u274C ${name}: ${error.message}`));
+      console.error(chalk54.red(`\u274C ${name}: ${error.message}`));
     }
   }
-  console.log(chalk47.green(`
+  console.log(chalk54.green(`
 \u{1F389} GMN \u914D\u7F6E\u5B8C\u6210\uFF01(${completed}/${tools.length})`));
-  console.log(chalk47.gray("\u63D0\u793A\uFF1A\u8BF7\u91CD\u542F\u5BF9\u5E94\u5DE5\u5177/\u63D2\u4EF6\u4EE5\u4F7F\u914D\u7F6E\u751F\u6548\u3002"));
+  console.log(chalk54.gray("\u63D0\u793A\uFF1A\u8BF7\u91CD\u542F\u5BF9\u5E94\u5DE5\u5177/\u63D2\u4EF6\u4EE5\u4F7F\u914D\u7F6E\u751F\u6548\u3002"));
 }
 
 // src/index.ts
 init_dist2();
 if (process.env.NODE_ENV === "development") {
-  console.log(chalk48.gray("\n[\u5F00\u53D1\u6A21\u5F0F] \u914D\u7F6E\u76EE\u5F55:"));
-  console.log(chalk48.gray(`  ccman: ${getCcmanDir()}`));
-  console.log(chalk48.gray(`  codex:  ${getCodexDir()}`));
-  console.log(chalk48.gray(`  claude: ${getClaudeDir()}`));
-  console.log(chalk48.gray(`  opencode: ${getOpenCodeDir()}`));
+  console.log(chalk55.gray("\n[\u5F00\u53D1\u6A21\u5F0F] \u914D\u7F6E\u76EE\u5F55:"));
+  console.log(chalk55.gray(`  ccman: ${getCcmanDir()}`));
+  console.log(chalk55.gray(`  codex:  ${getCodexDir()}`));
+  console.log(chalk55.gray(`  claude: ${getClaudeDir()}`));
+  console.log(chalk55.gray(`  opencode: ${getOpenCodeDir()}`));
+  console.log(chalk55.gray(`  openclaw: ${getOpenClawDir()}`));
   console.log();
 }
 var program = new Command3();
-program.name("ccman").description("Codex/Claude Code/Gemini/OpenCode API \u670D\u52A1\u5546\u914D\u7F6E\u7BA1\u7406\u5DE5\u5177").version(VERSION).showHelpAfterError(false).exitOverride((err) => {
+program.name("ccman").description("Codex/Claude Code/Gemini/OpenCode/OpenClaw API \u670D\u52A1\u5546\u914D\u7F6E\u7BA1\u7406\u5DE5\u5177").version(VERSION).showHelpAfterError(false).exitOverride((err) => {
   if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
     process.exit(0);
   }
@@ -6588,21 +7326,33 @@ program.name("ccman").description("Codex/Claude Code/Gemini/OpenCode API \u670D\
 });
 program.on("command:*", (operands) => {
   const unknownCommand = operands[0];
-  console.error(chalk48.red(`
+  console.error(chalk55.red(`
 \u274C \u672A\u77E5\u547D\u4EE4: ${unknownCommand}
 `));
-  const availableCommands = ["cx", "cc", "gm", "oc", "mcp", "sync", "export", "import", "gmn"];
+  const availableCommands = [
+    "cx",
+    "cc",
+    "gm",
+    "oc",
+    "openclaw",
+    "ow",
+    "mcp",
+    "sync",
+    "export",
+    "import",
+    "gmn"
+  ];
   const suggestions = availableCommands.filter(
     (cmd) => cmd.includes(unknownCommand) || unknownCommand.includes(cmd)
   );
   if (suggestions.length > 0) {
-    console.log(chalk48.yellow("\u{1F4A1} \u4F60\u662F\u4E0D\u662F\u60F3\u8F93\u5165:"));
+    console.log(chalk55.yellow("\u{1F4A1} \u4F60\u662F\u4E0D\u662F\u60F3\u8F93\u5165:"));
     suggestions.forEach((cmd) => {
-      console.log(chalk48.cyan(`   ccman ${cmd}`));
+      console.log(chalk55.cyan(`   ccman ${cmd}`));
     });
     console.log();
   }
-  console.log(chalk48.gray("\u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4: ") + chalk48.cyan("ccman --help"));
+  console.log(chalk55.gray("\u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4: ") + chalk55.cyan("ccman --help"));
   console.log();
   process.exit(1);
 });
@@ -6630,6 +7380,12 @@ oc.action(async () => {
   printLogo();
   await startOpenCodeMenu();
 });
+var openclaw = program.command("openclaw").alias("ow").description("\u7BA1\u7406 OpenClaw \u670D\u52A1\u5546");
+createOpenClawCommands(openclaw);
+openclaw.action(async () => {
+  printLogo();
+  await startOpenClawMenu();
+});
 var mcp = program.command("mcp").description("\u7BA1\u7406 MCP \u670D\u52A1\u5668");
 createMCPCommands(mcp);
 mcp.action(() => {
@@ -6643,7 +7399,7 @@ sync.action(async () => {
 });
 exportCommand(program);
 importCommand(program);
-program.command("gmn [apiKey]").description("\u914D\u7F6E GMN \u5230\u6240\u6709\u5DE5\u5177").option("-p, --platform <platforms>", "\u6307\u5B9A\u5E73\u53F0 (claude,codex,gemini,opencode,all)").action(async (apiKey, options) => {
+program.command("gmn [apiKey]").description("\u914D\u7F6E GMN \u5230 Codex\u3001OpenCode\u3001OpenClaw").option("-p, --platform <platforms>", "\u6307\u5B9A\u5E73\u53F0 (codex,opencode,openclaw,all)").action(async (apiKey, options) => {
   await gmnCommand(apiKey, options.platform);
 });
 (async () => {